1 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
3c3df58d8d Fix issue #100: Add walls to maps
Some checks failed
Test / test (push) Failing after 2s
2026-10-16 00:59:56 +00:00
64 changed files with 1625 additions and 5502 deletions

View File

@@ -83,12 +83,11 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings`
- `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`, `foundryPageId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color`
- `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs)
- `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
- `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`, or a full URL a synced scene's
picture arrives as), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`), `foundrySceneId` (the Foundry scene this map mirrors, unique per campaign)
- `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`)
- `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it
**API surface** (all under `/api`, all `{status,msg}`):
@@ -115,15 +114,11 @@ rest, expire after 10 min, and Obsidian gets a long-lived (365 d) token back.
Foundry then syncs with that token on `/api/foundry/sync/*` (`routes/foundry-link.js`, mounted before
the JWT guard; CORS opened for it): `snapshot` (actors + world items, `fullSync` also prunes),
`item-snapshot`, `item-delete`, `scenes` (the world's scenes as the campaign's maps, `fullSync` also
prunes), `scene-delete`, `characters`, `items`, `notes` / `map-note`, `status`, `unlink`,
`map` / `map-item`, `delete`. Rules:
`item-snapshot`, `item-delete`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules:
- **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row.
- **Only the world's item directory reaches the item list** (Syndria98/dragonroll#67) — `snapshotItemSources` reads `body.items` (`game.items`) alone; gear embedded in a character is that actor's `inventory` (see the `Actor` model), not an `Item`. A world item still folds into a hand-made or renamed row it matches by name (`foundryNames`), so a rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped.
- **Item folders mirror the world's item directory** (`Folder.foundryFolderId`, target `item`): every push carries the whole tree and the world owns its names and nesting. `color` is the one field the campaign sets too, so it travels back with the folders `GET /foundry/sync/items` answers with (`{items, folders}`) and the module writes it onto the world's folder.
- **A world's scenes arrive as its campaign's maps** (Syndria98/dragonroll#99): `POST /foundry/sync/scenes` writes one `Map` per scene through `saveFoundryScene`, and only the scene's background picture and grid cross over (`services/map-foundry.js`: `gridSize` from `grid`/`grid.size`, the offsets from `flags.core.shiftX`/`.shiftY`) — `scale`, the folder, the pins and the tokens stay with the campaign and nothing of a map goes back to the world. Identity is `Map.foundrySceneId` (unique per campaign), a `dragonroll-foundry.mapId` flag or a hand-made unmapped map of the same name; a scene with no picture makes no map. `POST /foundry/sync/scene-delete` drops the map of a deleted scene, and only the full list the module sends when the world links or loads prunes.
- **Notes reach the world as journal pages, one way** (Syndria98/dragonroll#98): the module reads `GET /sync/notes` and stands each campaign folder as a world `JournalEntry` named after its path (root notes share `Dragonroll`, a note in `Sessions/Arc 1` gets `Sessions / Arc 1`) — the page carries the note's id in a `dragonroll-foundry.noteId` flag, the note keeps the page's id in `foundryPageId` (`POST /sync/map-note`). The backend computes the path (`folderPath`) and includes it in the revision hash, so a rename or move reaches the world. The reconcile rewrites pages from the notes, moves a note's page when it changes folder, renames a folder journal with its folder and drops the page of a deleted note; journal edits never travel back. A folder journal with no notes left goes unless the GM keeps pages of their own in it, and a world holding several journals for root notes keeps only the one the notes live in. The poll asks `GET /sync/notes/revision` (a hash of the notes and folder paths) every 15 s and only pulls the notes over when that hash or the pages it last wrote have changed, so an untouched campaign is not re-read and rewritten every few seconds. A note's `@roll` widgets are drawn as buttons in the page: a delegated click handler evaluates the expression with Foundry's `Roll` and posts it to chat (`adv`/`dis` become `kh1`/`kl1`).
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune.
- **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`).
- `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. Its one write, `POST /import`, pulls the bridge's actors or world items into the campaign through the same writers as a sync push.

View File

@@ -86,14 +86,6 @@ const ActorSchema = new Schema({
// for, shown on the left of the inventory row.
icon: { type: String, default: '' }
}],
// The character's features as the world writes them (Syndria98/dragonroll#89): one row
// per Foundry `feat` item, with the item's own picture and text. The free-form `traits`
// above keeps the details a world has no item for.
features: [{
name: { type: String, trim: true, default: '' },
description: { type: String, default: '' },
icon: { type: String, default: '' }
}],
traits: { type: String, default: '' },
spells: { type: String, default: '' },
campaign: {

View File

@@ -27,6 +27,19 @@ const MapSchema = new Schema({
x: { type: Number, default: 0 },
y: { type: Number, default: 0 }
}],
// Segments that block the map like walls. The endpoints are image pixels from the top left corner
// of the image, like a pin — and the very space Foundry draws a scene's walls in, so a paired
// scene and map trade them as they stand. `move`/`sight` say what passes through the segment, and
// `door` is 0 (not a door), 1 (open) or 2 (closed), following Foundry's own wall values.
walls: [{
x1: { type: Number, default: 0 },
y1: { type: Number, default: 0 },
x2: { type: Number, default: 0 },
y2: { type: Number, default: 0 },
move: { type: Boolean, default: true },
sight: { type: Boolean, default: true },
door: { type: Number, min: 0, max: 2, default: 0 }
}],
campaign: {
type: Schema.Types.ObjectId,
ref: 'Campaign',
@@ -39,12 +52,13 @@ const MapSchema = new Schema({
ref: 'Folder',
default: null
},
// The Foundry scene this map mirrors, set by the scene sync only
// (see routes/foundry-link.js). Only the picture and the grid follow the world.
// The Foundry scene whose walls this map mirrors once the linked world has paired them (see
// routes/foundry-link.js): the whole wall set of one is the whole wall set of the other.
foundrySceneId: { type: String },
date: { type: Date, default: Date.now }
});
// A scene walls one map of a campaign at most, like a Foundry actor one actor row.
MapSchema.index(
{ campaign: 1, foundrySceneId: 1 },
{ unique: true, partialFilterExpression: { foundrySceneId: { $type: 'string' } } }

View File

@@ -14,17 +14,7 @@ const NoteSchema = new Schema({
ref: 'Folder'
},
color: { type: String },
// The journal page this note is written as in the linked Foundry world: a page
// of the journal of this note's folder (root notes: "Dragonroll") whose rows
// carry this note's id in their `dragonroll-foundry.noteId` flag (see the
// module's notes sync).
foundryPageId: { type: String },
date: { type: Date, default: Date.now }
});
NoteSchema.index(
{ campaign: 1, foundryPageId: 1 },
{ unique: true, partialFilterExpression: { foundryPageId: { $type: 'string' } } }
);
module.exports = mongoose.model('Note', NoteSchema);

View File

@@ -74,7 +74,7 @@ router.post('/update', async (req, res) => {
try {
const {
id, name, species, className, subclass, level, abilityScores, armorClass, speed, hitPoints, hitDice,
proficiencies, skills, savingThrows, tools, languages, currency, inventory, features, traits, spells, image, folder
proficiencies, skills, savingThrows, tools, languages, currency, inventory, traits, spells, image, folder
} = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
@@ -111,7 +111,6 @@ router.post('/update', async (req, res) => {
if (languages !== undefined) actor.languages = textList(languages);
if (currency !== undefined) actor.currency = currency;
if (inventory !== undefined) actor.inventory = inventory;
if (features !== undefined) actor.features = features;
if (traits !== undefined) actor.traits = traits;
if (spells !== undefined) actor.spells = spells;
if (image !== undefined) actor.image = String(image);

View File

@@ -8,11 +8,12 @@ const serviceLinks = require('../services/service-links');
// Every service links to a campaign through the same sign-up link
// (routes/service-link.js); a campaign only drops one of them again.
async function unlinkService(campaign, service) {
// A Foundry world can also let the campaign go from the module itself
// (routes/foundry-link.js), so both go through the same helper.
if (service === 'foundry') return serviceLinks.unlinkFoundryWorld(campaign);
if (service === 'discord') {
if (service === 'foundry') {
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
} else if (service === 'discord') {
// The Discord account the bot answers to stays: the server is simply
// left without a campaign until somebody picks one again.
campaign.discordGuildId = undefined;

View File

@@ -6,15 +6,12 @@ const router = express.Router();
const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor');
const Item = require('../models/Item');
// Not `Map`: this route builds plain `Map`s of its own to mirror the world's folder tree.
const MapModel = require('../models/Map');
const Folder = require('../models/Folder');
const Note = require('../models/Note');
// `MapModel`, not `Map`: this file uses the built-in `Map` for the item folder maps.
const MapModel = require('../models/Map');
const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry');
const { foundrySceneToMapData } = require('../services/map-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
const serviceLinks = require('../services/service-links');
// Upper bound for the Foundry names remembered per synced item (see Item model).
const MAX_FOUNDRY_NAMES = 20;
@@ -67,14 +64,11 @@ function resolveWorldAssets(fields, campaign) {
if (Array.isArray(fields.inventory)) {
for (const entry of fields.inventory) entry.icon = worldAssetUrl(entry.icon, worldUrl);
}
if (Array.isArray(fields.features)) {
for (const entry of fields.features) entry.icon = worldAssetUrl(entry.icon, worldUrl);
}
}
async function saveFoundryActor(campaign, source, fullSync = false, replace = false) {
async function saveFoundryActor(campaign, source, fullSync = false) {
const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryActorToCharacter(source || {}, replace);
const fields = foundryActorToCharacter(source || {});
if (!foundryActorId || !fields.name) return null;
resolveWorldAssets(fields, campaign);
@@ -276,47 +270,6 @@ function resolveFoundryItemFolder(source, folders) {
return folders.get(foundryFolderId.trim())?._id || null;
}
// --- Maps -------------------------------------------------------------------
// A scene of the world becomes one of the campaign's maps (Syndria98/dragonroll#99):
// services/map-foundry.js says what of a scene travels — its background picture and the
// grid laid over it, and nothing else, so the map's pins, its tokens, the folder it
// stands in and what one of its cells means stay the campaign's own.
async function saveFoundryScene(campaign, source, fullSync = false) {
const foundrySceneId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundrySceneToMapData(source || {});
if (!foundrySceneId || !fields) return null;
resolveWorldAssets(fields, campaign);
let map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId });
const dragonrollMapId = source?.flags?.['dragonroll-foundry']?.mapId;
if (!map && mongoose.isValidObjectId(dragonrollMapId)) {
const flagged = await MapModel.findOne({ _id: dragonrollMapId, campaign: campaign._id });
// Only adopt a flagged map while no other scene owns its mapping.
if (flagged && (!flagged.foundrySceneId || flagged.foundrySceneId === foundrySceneId)) map = flagged;
}
if (!map) {
// The campaign drew this place by hand before the scene of it ever arrived: a scene
// naming the one unmapped map the campaign holds folds into that row instead of
// adding a second copy of the same room.
const sameName = await MapModel.find({
campaign: campaign._id,
name: fields.name,
foundrySceneId: { $exists: false }
}).limit(2);
map = sameName.length === 1 ? sameName[0] : new MapModel({ campaign: campaign._id });
}
map.foundrySceneId = foundrySceneId;
// `created` says whether this row is new, like the actor and item writers answer it.
const created = map.isNew;
// A full snapshot runs when a GM reconnects: the grid the campaign lined up for a map
// it already has survives that. Live scene edits continue to overwrite normally.
if (!fullSync || map.isNew) Object.assign(map, fields);
await map.save();
return { foundrySceneId, mapId: map.id, created };
}
// Linking a world to a campaign happens through the sign-up link every service
// uses (routes/service-link.js); what stays here is the sync that world keeps up
@@ -353,16 +306,12 @@ router.post('/sync/snapshot', async (req, res) => {
}
const fullSync = req.body.fullSync === true;
// A forced actor sync from the module's context menu replaces the campaign's
// row for the actors it sends entirely (Syndria98/dragonroll#96). It stays
// clear of fullSync: it never prunes, unlike a reconnect's full snapshot.
const replace = req.body.replace === true;
// A module that knows nothing about item folders sends neither the tree
// nor the folder of an item, and then nothing here touches the folders.
const folderSources = Array.isArray(req.body.folders) ? req.body.folders : null;
const actors = [];
for (const source of actorSources || []) {
const mapping = await saveFoundryActor(campaign, source, fullSync, replace);
const mapping = await saveFoundryActor(campaign, source, fullSync);
if (mapping) actors.push(mapping);
}
const itemFolders = folderSources ? await syncFoundryItemFolders(campaign, folderSources) : null;
@@ -487,59 +436,6 @@ router.post('/sync/item-delete', async (req, res) => {
}
});
// The world's scenes, upserted as the campaign's maps (Syndria98/dragonroll#99). Like a
// world item push, this one prunes only when it is told it carries every scene: that push
// alone sees the whole scene list, so it alone knows which synced maps the world has let go
// of. A map the campaign made by hand has no scene of its own and is never pruned.
router.post('/sync/scenes', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
if (!requestMatchesWorld(campaign, req.body.worldId) || !Array.isArray(req.body.scenes)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const fullSync = req.body.fullSync === true;
const maps = [];
for (const source of req.body.scenes) {
const mapping = await saveFoundryScene(campaign, source, fullSync);
if (mapping) maps.push(mapping);
}
if (fullSync) {
const currentIds = req.body.scenes
.map((source) => String(source?._id || source?.id || '').trim())
.filter(Boolean);
await MapModel.deleteMany({
campaign: campaign._id,
foundrySceneId: { $exists: true, $nin: currentIds }
});
}
res.json({ status: 'ok', maps });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// A scene the world deleted takes its map with it. Only the world says so; deleting a map
// in the campaign leaves the world's scene alone, which is the campaign's own to do.
router.post('/sync/scene-delete', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const foundrySceneId = String(req.body.foundrySceneId || '').trim();
if (!requestMatchesWorld(campaign, req.body.worldId) || !foundrySceneId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
await MapModel.deleteOne({ campaign: campaign._id, foundrySceneId });
res.json({ status: 'ok' });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The item list the world reconciles against, together with the folders its rows are
// grouped into — the same shape the campaign's own `/item/list` answers with. The folders
// travel back for their colour: the world owns the tree's name and nesting, while whoever
@@ -583,135 +479,97 @@ router.post('/sync/map-item', async (req, res) => {
}
});
// --- Note pages ------------------------------------------------------------
// The campaign's notes are read where their authors' table sits: each note
// stands as a page of the journal of the folder it lives in, and root notes share
// the journal the world calls "Dragonroll". Notes are written in Dragonroll, so
// this copy runs one way — the module reads the notes and rewrites their pages;
// nothing of the journal travels back. Its pages keep the note's id in a
// `dragonroll-foundry.noteId` flag, and the note keeps the page's id here, so
// either side recognises the pairing again after a restart.
// --- Scene walls -----------------------------------------------------------
// A campaign map can mirror the walls of a Foundry scene: the whole set travels whoever edits
// it, so the map's editor and the scene's wall tool see the same segments. A map is paired with
// a scene by name while the module reconciles its campaign — the way an unmapped item maps to
// the world document it shares its name with — and `POST /sync/map-scene` records that pairing.
// The endpoints are image pixels of the scene's background there too, so a segment crosses
// unchanged; `door` follows Foundry's own wall values (1 open, 2 closed), and locked doors
// arrive closed.
const NOTE_FOLDER_SEPARATOR = ' / ';
// Same shape the campaign's own `/map/walls` saves by: finite endpoints or nothing, whole pixels
// that never go off the top left corner, no segment without length.
function toSyncedWall(source) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
// The path of the folder a note lives in, from the root down: the module names a
// journal after it, so a note in "Sessions / Arc 1" is written into that journal.
// A broken parent chain stops at the first folder seen twice instead of looping.
function noteFolderPath(folderId, foldersById) {
const names = [];
const seen = new Set();
let folder = folderId ? foldersById.get(String(folderId)) : null;
while (folder && !seen.has(String(folder._id))) {
seen.add(String(folder._id));
if (folder.name) names.unshift(String(folder.name));
folder = folder.parentFolder ? foldersById.get(String(folder.parentFolder)) : null;
}
return names.join(NOTE_FOLDER_SEPARATOR);
const toPixel = (value) => Math.max(0, Math.round(Number(value)));
const wall = {
x1: toPixel(source.x1),
y1: toPixel(source.y1),
x2: toPixel(source.x2),
y2: toPixel(source.y2),
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
return wall.x1 === wall.x2 && wall.y1 === wall.y2 ? null : wall;
}
// The note folders of a campaign, keyed by id, for the path of each note.
async function campaignNoteFolders(campaignId) {
const folders = await Folder.find({ campaign: campaignId })
.select('_id name parentFolder')
.lean();
return new Map(folders.map((folder) => [String(folder._id), folder]));
}
// A cheap summary of the campaign's notes for the module's change check: the same
// notes `/sync/notes` would send, folded into one hash, so a world can tell whether
// anything changed without pulling every note's markdown over on every poll. The
// folder path travels in the hash too: renaming or moving a folder moves a note to
// another journal. The page a note is already mapped to is left out — mapping is
// not an edit.
router.get('/sync/notes/revision', async (req, res) => {
// The maps the module pairs scenes with and reconciles walls against: what a wall set needs to
// land on a scene, and nothing the module has no use for.
router.get('/sync/maps', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const notes = await Note.find({ campaign: campaign._id })
.select('_id title content folder')
.sort({ _id: 1 })
const maps = await MapModel.find({ campaign: campaign._id })
.select('_id name image foundrySceneId walls')
.sort({ name: 1 })
.lean();
const foldersById = await campaignNoteFolders(campaign._id);
const revision = crypto.createHash('sha256')
.update(notes.map((note) => [
note._id,
note.title ?? '',
note.content ?? '',
note.folder ?? '',
noteFolderPath(note.folder, foldersById),
].join('\u0000')).join('\u0001'))
.digest('hex');
res.json({ status: 'ok', revision });
res.json({ status: 'ok', maps });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Every note of the campaign, content included: enough for the module to write
// each one as a page. A note also carries the path of its folder, which names the
// journal the page belongs to; root notes carry an empty path.
router.get('/sync/notes', async (req, res) => {
router.post('/sync/map-scene', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const notes = await Note.find({ campaign: campaign._id })
.select('_id title content foundryPageId date folder')
.sort({ date: -1 })
.lean();
const foldersById = await campaignNoteFolders(campaign._id);
res.json({
status: 'ok',
notes: notes.map((note) => ({
...note,
folderPath: noteFolderPath(note.folder, foldersById),
})),
});
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The page the module made for a note, kept on the note so the next reconcile —
// or a world whose page flags were lost — writes that page instead of a second
// one under the same title.
router.post('/sync/map-note', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { noteId, foundryPageId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !noteId || !foundryPageId) {
const { mapId, foundrySceneId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !mapId || !foundrySceneId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const note = await Note.findOne({ _id: noteId, campaign: campaign._id });
if (!note) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await Note.findOne({ campaign: campaign._id, foundryPageId, _id: { $ne: note._id } });
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.note-already-synced' });
const map = await MapModel.findOne({ _id: mapId, campaign: campaign._id });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await MapModel.findOne({
campaign: campaign._id,
foundrySceneId: String(foundrySceneId).trim(),
_id: { $ne: map._id }
});
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.scene-already-synced' });
note.foundryPageId = String(foundryPageId).trim().slice(0, 120);
await note.save();
res.json({ status: 'ok', note });
map.foundrySceneId = String(foundrySceneId).trim().slice(0, 120);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// A world letting its campaign go from the module settings: the campaign forgets
// the world and the token this request used stops working, so the world is free
// to pair again — and the campaign's settings stop listing it as connected.
router.post('/sync/unlink', async (req, res) => {
// A scene's whole wall set, as the module draws it: the paired map takes it over, like the
// world's item folders take over the campaign's tree. A scene the campaign has no map paired
// with answers `notfound` — most scenes are none of the campaign's business.
router.post('/sync/map-walls', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
if (!requestMatchesWorld(campaign, req.body.worldId)) {
const { foundrySceneId, walls, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !foundrySceneId || !Array.isArray(walls)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
await serviceLinks.unlinkFoundryWorld(campaign);
res.json({ status: 'ok' });
const map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: String(foundrySceneId).trim() });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
map.walls = walls.map(toSyncedWall).filter(Boolean);
await map.save();
res.json({ status: 'ok', map: { _id: map.id } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });

View File

@@ -238,4 +238,50 @@ router.post('/remove-token', async (req, res) => {
}
});
// A wall is a segment of the map that blocks it like one does. The editor saves the whole set at
// once — drawing, moving, re-typing and taking off segments are all the same request — and a paired
// Foundry scene takes that set whole too, so the set is the contract on both sides. Endpoints are
// image pixels like a pin's, and a wall keeps the `_id` it is sent with when one of the current
// walls has it, so the markers on screen do not jump through a save. A segment with no length is
// dropped: it is a click that was not meant to draw anything.
function toStoredWall(source, currentWalls) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
const wall = {
x1: toCoordinate(source.x1),
y1: toCoordinate(source.y1),
x2: toCoordinate(source.x2),
y2: toCoordinate(source.y2),
// What the editor draws is a wall, not an opening: both stay out unless it says otherwise.
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return null;
const id = String(source?._id ?? '').trim();
if (id && currentWalls.some((current) => String(current?._id) === id)) wall._id = id;
return wall;
}
router.post('/walls', async (req, res) => {
try {
const { id, walls } = req.body;
if (!id || !Array.isArray(walls)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const currentWalls = Array.from(map.walls ?? []);
map.walls = walls.map((source) => toStoredWall(source, currentWalls)).filter(Boolean);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router;

View File

@@ -111,34 +111,26 @@ function foundryCurrency(system) {
return Object.fromEntries(CURRENCIES.map((key) => [key, Math.max(0, numberOr(coins[key], 0))]));
}
// The character's features: D&D 5e files species, background, class and monster features
// under the `feat` item type, each with its text and picture on the item. They are what
// the sheet's traits tab lists, one row per feature.
function foundryFeatures(items) {
return items
.filter((item) => item.type === 'feat')
.map((item) => ({
name: asText(item.name).trim(),
description: plainText(item.system?.description?.value ?? item.system?.description),
icon: asText(item.img).trim()
}))
.filter((feature) => feature.name);
}
// The free-form traits text: the details field some system releases keep, or what the
// campaign wrote and the module carries back on its flag. `undefined` says the world
// holds no text of its own, which keeps a live edit from clearing the campaign's.
function foundryTraits(source, savedDragonrollFields, replace) {
// The character's traits as the world writes them: the free-text details field some
// system releases keep, or its trait items, which are how a monster's traits and a
// character's racial and class features are written. `undefined` says the world holds
// no traits to show.
function foundryTraits(source, items) {
const text = plainText(source.system?.details?.trait);
const campaignTraits = replace ? '' : asText(savedDragonrollFields.traits);
return text || campaignTraits || undefined;
if (text) return text;
const features = items
.filter((item) => item.type === 'feat' && stringList(item.system?.featType?.value ?? item.system?.featType)
.some((type) => asText(type).toLowerCase().startsWith('tr')))
.map((item) => {
const name = asText(item.name).trim();
const description = plainText(item.system?.description?.value ?? item.system?.description);
return name ? `${name}\n${description}`.trim() : '';
})
.filter(Boolean);
return features.length ? features.join('\n\n') : undefined;
}
// `replace` is a forced actor sync from the module's context menu (Syndria98/dragonroll#96):
// it replaces everything the campaign holds for this actor, so the fields a live edit
// leaves out when the world says nothing are written empty instead of kept. A live Foundry
// change passes `false` and keeps the campaign's own toggles and text.
function foundryActorToCharacter(foundryActor, replace = false) {
function foundryActorToCharacter(foundryActor) {
const system = foundryActor.system || {};
const details = system.details || {};
const abilities = system.abilities || {};
@@ -177,9 +169,7 @@ function foundryActorToCharacter(foundryActor, replace = false) {
])),
armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10),
speed: numberOr(movement.walk ?? movement.value, 30),
// A replace takes the world's text even when it has none, so what Dragonroll
// cached on the actor's flag does not survive it; a live edit keeps that text.
proficiencies: foundryProficiencies || (replace ? '' : asText(savedDragonrollFields.proficiencies)),
proficiencies: foundryProficiencies || asText(savedDragonrollFields.proficiencies),
// What the character carries: gear, and gear only (Syndria98/dragonroll#89). A feat
// is a trait — its tab shows it — and a race is the species; standing them in the
// inventory next to the longswords is how traits and items got mixed up.
@@ -192,11 +182,7 @@ function foundryActorToCharacter(foundryActor, replace = false) {
icon: asText(item.img).trim()
}))
.filter((item) => item.name),
spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n'),
// The features themselves, icons and all: the traits tab draws them like the
// inventory, and a live edit sends the world's whole item list, so a feature the
// GM removed in Foundry goes here too.
features: foundryFeatures(items)
spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n')
};
// What the world says about each of these, when it says anything: leaving a field
@@ -214,20 +200,9 @@ function foundryActorToCharacter(foundryActor, replace = false) {
if (languages) fields.languages = languages;
const currency = foundryCurrency(system);
if (currency) fields.currency = currency;
const worldTraits = foundryTraits(foundryActor, savedDragonrollFields, replace);
if (worldTraits) fields.traits = worldTraits;
// A replace writes the fields a live edit would leave out when the world says
// nothing, so the campaign's toggles, lists and text for this actor go with it and
// the row reads as the Foundry actor alone (Syndria98/dragonroll#96).
if (replace) {
if (fields.skills === undefined) fields.skills = {};
if (fields.savingThrows === undefined) fields.savingThrows = {};
if (fields.tools === undefined) fields.tools = [];
if (fields.languages === undefined) fields.languages = [];
if (fields.currency === undefined) fields.currency = {};
if (fields.traits === undefined) fields.traits = '';
}
const worldTraits = foundryTraits(foundryActor, items);
const campaignTraits = asText(savedDragonrollFields.traits);
if (worldTraits || campaignTraits) fields.traits = worldTraits || campaignTraits;
return fields;
}

View File

@@ -1,49 +0,0 @@
const { numberOr, asText } = require('./foundry-fields');
// A Foundry scene is one of the campaign's maps (Syndria98/dragonroll#99): its background
// picture and the grid laid over it travel to Dragonroll. Everything else a scene holds —
// its padding, its lighting, the tokens standing on it — belongs to the world's table, and
// so does what one of its cells stands for (`gridDistance` with its units): the campaign
// sets its own scale and keeps it.
// The scene's background picture: `background.src` since Foundry V13, plain `img` before.
function sceneImage(scene) {
return asText(scene?.background?.src).trim() || asText(scene?.img).trim();
}
// How many pixels of the picture one grid cell covers. Foundry keeps it under `grid.size`
// since V13 and under plain `grid` before; 50 px is its own default cell size, and
// Dragonroll's is the same, so a scene that says nothing gets the grid it draws.
function sceneGridSize(scene) {
const size = numberOr(scene?.grid?.size ?? scene?.grid, 0);
return size >= 1 ? Math.round(size) : 50;
}
// Where that grid starts on the picture. A world shifts it with the core flags of its own
// (`flags.core.shiftX` / `.shiftY`, what it uses to line a hexagonal grid up); one that says
// nothing has its grid at the corner of the picture. The scene's padding is blank canvas
// *outside* the picture, so it is no part of the grid the campaign lays on the picture itself.
function sceneGridOffset(scene, axis) {
return Math.round(numberOr(scene?.flags?.core?.[`shift${axis}`], 0));
}
// Returns null for a scene that is not a map: one with no name, or with no background
// picture. A Dragonroll map without a picture is an empty viewer, so those scenes stay in
// the world — their id is still listed by the snapshot that carries them, so nothing of the
// campaign is pruned because of one.
function foundrySceneToMapData(scene) {
const name = asText(scene?.name).trim();
const image = sceneImage(scene);
if (!name || !image) return null;
return {
name,
// The module sends Foundry's picture as an absolute URL, like actors do.
image,
gridSize: sceneGridSize(scene),
offsetX: sceneGridOffset(scene, 'X'),
offsetY: sceneGridOffset(scene, 'Y')
};
}
module.exports = { foundrySceneToMapData };

View File

@@ -13,10 +13,6 @@ const NOTIFICATION_WINDOW_MS = 15 * 60 * 1000;
// somebody to open the sign-up link again every 48 hours. It carries the id of the link so that
// revoking the link works right away — see services/passport.js.
const OBSIDIAN_TOKEN_TTL = '365d';
// A service describes itself with a handful of short values (its Foundry system, its Discord
// user id...), and those are shown to the user who answers the link, so both are capped.
const MAX_META_ENTRIES = 10;
const MAX_META_VALUE_LENGTH = 200;
// Every service that connects to a campaign does it the same way: it asks the
// backend for a sign-up link, shows it to the person sitting in front of it,
@@ -165,9 +161,7 @@ async function startServiceLink(service, target) {
async function findServiceLinkByCode(code) {
if (!code) return null;
// Not `.lean()`: the link answered by /complete is saved back with its new
// state, and a plain object has no document behind it to save.
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials');
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean();
}
// The credential that belongs to a link is handed over once and then dropped:
@@ -213,18 +207,6 @@ async function revokeServiceLink(service, campaignId) {
return result.matchedCount;
}
// A campaign letting a Foundry world go: it forgets the world, which frees the
// world to pair with a campaign again, and the token the world still holds stops
// working the next time it asks.
async function unlinkFoundryWorld(campaign) {
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
await campaign.save();
await revokeServiceLink('foundry', campaign._id);
}
// What a campaign has connected to it, newest link first and one row per
// service, so the campaign settings can list its services together.
async function listLinkedServices(campaignId) {
@@ -268,6 +250,5 @@ module.exports = {
serviceName,
signUpLinkUrl,
startServiceLink,
takeServiceLinkCredentials,
unlinkFoundryWorld
takeServiceLinkCredentials
};

View File

@@ -3,7 +3,7 @@
Foundry modules run in the game client, so the module cannot bind an HTTP port on the Foundry host.
This integration uses a small companion bridge process on that host:
1. A linked GM client syncs character Actors, world Items and Scenes directly with the Dragonroll campaign.
1. A linked GM client syncs character Actors and world Items directly with the Dragonroll campaign.
2. The module publishes the active world's actor and item snapshot to the optional bridge.
3. The bridge serves authenticated HTTP read endpoints that Dragonroll proxies under `/api/foundry/*`.
@@ -11,13 +11,7 @@ The Foundry module uses the client-side package API and hooks documented by Foun
## 1. Install the Foundry module
In Foundry's **Setup → Add-on Modules → Install Module**, paste the manifest URL
`https://dragonroll.aranroig.com/foundry/module.json`. The frontend serves that manifest and the
zip it points to (`/foundry/dragonroll-foundry.zip`), both built from this directory, and the same
manifest URL is what Foundry checks for updates. A self-hosted Dragonroll serves it at
`https://<your-dragonroll-host>/foundry/module.json`.
Alternatively, copy the contents of this directory into
Copy the contents of this directory into
`{Foundry user data}/Data/modules/dragonroll-foundry/`. Restart Foundry, then enable **Dragonroll
Foundry API** in the world's module settings.
@@ -43,8 +37,9 @@ settings screen re-displays it after a page reload, the window being closed, or
example one pasted while Dragonroll was restarting — retrying it at world startup and once a minute
until the world finishes linking.
For a local backend, use `http://localhost:5000`; the module adds `/api` like it does for any other
server. Character synchronization works without the optional snapshot bridge. Configure that bridge only if you also need the read-only world snapshot API described below.
For a local backend, use `http://localhost:5000`; the module omits `/api` and the backend accepts
the local pairing route at its root. Character synchronization works without the optional snapshot
bridge. Configure that bridge only if you also need the read-only world snapshot API described below.
**Dragonroll Pairing Status** in the module settings always says whether this browser holds a pairing
and, once Dragonroll has answered `GET /api/foundry/sync/status`, which campaign the world is
@@ -54,13 +49,6 @@ gives the reason when a pairing code can never be redeemed, and says the world i
once the campaign unlinks it. Because both the pairing code and the sync token are client settings,
another browser of the same world reads as not paired.
**Dragonroll Connection** in the module settings opens the same state with the two actions a GM needs:
**Copy link** puts the sign-up link on the clipboard to hand to whoever will pick the campaign, and
**Unlink campaign** lets the world go. Unlinking drops the token on this client and on the campaign
(`POST /api/foundry/sync/unlink`), so the campaign's settings stop listing the world and it can be
paired again. If Dragonroll cannot be reached the token is kept and the failure is reported instead —
dropping it alone would leave the campaign still believing the world is connected.
The campaign settings show the linked world's title and system. A Foundry world can be linked to
only one campaign at a time. The pairing endpoint accepts cross-origin requests from the Foundry
client and uses the one-time code instead of a Dragonroll login token.
@@ -85,11 +73,9 @@ queued while it was off are sent as the world catches up.
With autosync off — or any time a single character needs to cross over right now — right-click an
actor (or several selected ones) in the Foundry actor directory and pick **Dragonroll: Force Sync**.
Those actors, together with the gear carried inside them, are pushed to the campaign immediately even
when autosync is off, **replacing everything that campaign holds for them** (Syndria98/dragonroll#96):
what the campaign had edited on those actors is written over by what the world says. It replaces
those actors only — it never prunes the campaign's other actors, which a full snapshot does and a
forced sync never claims to. Actors Dragonroll does not import (anything that is not a character, NPC
or creature) are refused with a notification.
when autosync is off. It is an upsert only: it never prunes the campaign's other actors, which a full
snapshot does and a forced sync never claims to. Actors Dragonroll does not import (anything that is
not a character, NPC or creature) are refused with a notification.
The optional read-only snapshot bridge is not affected: it keeps publishing the world snapshot behind
`/api/foundry/*`, which is never written into the campaign.
@@ -119,61 +105,6 @@ else (Syndria98/dragonroll#67):
the whole world directory and can tell which synced rows it has let go of. Deleting a synced item in
Dragonroll removes its Foundry world copy on the next reconcile.
### Maps
A scene of the world is one of the campaign's maps (Syndria98/dragonroll#99), and only two things
about it cross over: the scene's **background picture** and the **grid** laid over it.
- The picture is sent as an absolute URL of this world, the way an actor's portrait is, so the
campaign draws the same battle map the table is looking at. Its cell size is the scene's own
(`grid`, and `grid.size` since Foundry V13), and the grid starts where the world shifts it
(`flags.core.shiftX` / `.shiftY`). A scene with no background picture makes no map.
- Everything else a scene holds stays in the world, and everything else a map holds stays in the
campaign: what one of its cells stands for, the folder it stands in, the notes pinned onto it and
the actors standing on it as tokens are the campaign's own. Nothing of a map is written back into
the world — scene sync runs one way, so a map deleted in the campaign comes back with its scene on
the next full list, and taking the scene off is what ends the map.
- A scene is matched to a map by its Foundry id, kept on the map as `foundrySceneId` (unique within
the campaign). A campaign that drew the same place by hand before its scene arrived is adopted
instead of doubled: the scene takes over the unmapped map holding its name.
- Live scene edits overwrite the map, including a picture and grid the campaign had set itself; a
full snapshot (the world linking or loading) leaves a map it already has alone. The maps of scenes
the world let go of are pruned by a full snapshot only, and a scene deleted in the world is
reported on `foundry/sync/scene-delete`.
- Autosync covers maps like everything else: turned off, no scene crosses over at all, and the ones
queued while it was off go over when it is turned back on.
### Notes
The campaign's notes read like the campaign's journal in the world (Syndria98/dragonroll#98): each
folder stands as a JournalEntry named after its path. Notes in the root of the campaign share the
journal called **Dragonroll**, and notes in a folder called *Sessions* with a subfolder *Arc 1* share
the journal **Sessions / Arc 1**; a note is always a page of the journal of its folder. The module
creates those journals — or adopts ones the GM already made under the same name, marking them as the
notes' journals — and renders each note's markdown into the page's HTML (headings, lists, quotes,
code and the inline marks), so the page reads in the journal the way the note reads in Dragonroll. A
note's dice widgets become buttons in the page too: pressing one rolls the expression with Foundry's
own dice and posts the result to chat (`adv`/`dis` are sent as `kh1`/`kl1`), so the note rolls at the
table without going back to the app. Its `[[Name]]` links become Foundry content links that open the
note page, character, item or scene they name, and `![[Name]]` embeds a character or an item as a
sheet preview right in the page (Foundry's `@UUID` and `@Embed` enrichers). A name the world has no
document for is shown dimmed, the way Dragonroll dims a link to an entry it cannot find. If a folder
is renamed, its journal is renamed with it, and
moving a note to another folder moves its page to that folder's journal. Notes are written in
Dragonroll, so this copy runs one way: a note made or edited in the campaign rewrites its page, and a
note deleted there takes its page with it. Pages the campaign does not own — the GM's own pages in
those journals — are left alone, and nothing written in a journal travels back. A folder journal whose
notes have all moved or gone is removed too, unless the GM keeps pages of their own in it. Autosync
off stops it too, like the rest of the sync.
Unlike the actor and item reconciles, the notes are only pulled over when something moved. Every
fifteen seconds the module asks for `GET /api/foundry/sync/notes/revision` — a hash of the campaign's
notes and their folder paths — and compares it with the pages it last wrote into the journals. While
both are unchanged the check stops there, so an idle campaign costs one hash comparison instead of a
pull of every note and a journal rewrite. A note made, edited, moved or deleted in Dragonroll, a
folder renamed, or a page of a notes' journal the GM changed or removed, moves one of the two and the
next check writes the pages in step again.
The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
| Route | Use |
@@ -181,22 +112,14 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/snapshot` | Actors and world items upsert; `fullSync` also prunes |
| `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only |
| `POST /api/foundry/sync/item-delete` | A world item was deleted |
| `POST /api/foundry/sync/scenes` | The world's scenes upsert as the campaign's maps; `fullSync` also prunes |
| `POST /api/foundry/sync/scene-delete` | A scene was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry |
| `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/notes` | The campaign's notes, markdown and all, their folder path, and the journal page each stands as |
| `GET /api/foundry/sync/notes/revision` | A hash of the campaign's notes and folder paths, for the module's change check |
| `POST /api/foundry/sync/map-note` | Store a note's journal page id after creating that page |
| `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status |
| `POST /api/foundry/sync/unlink` | The module unlinks the world; the campaign forgets it and the token is revoked |
| `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted |
Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId`
flag, and a journal page the module made for a note keeps its note's id in the `dragonroll-foundry.noteId`
flag, so the notes reconcile recognises its own pages. World items are marked with
`dragonroll-foundry.syncMutation` while Dragonroll writes them so
flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so
the write is not echoed back. A folder colour is written with that folder held in the client's set of
folders being synced, for the same reason.

View File

@@ -2,16 +2,13 @@
"id": "dragonroll-foundry",
"title": "Dragonroll Foundry API",
"description": "Links a Foundry world to a Dragonroll campaign and exposes a client-side API for world data.",
"version": "0.7.0",
"version": "0.4.0",
"library": true,
"compatibility": {
"minimum": "14",
"minimum": "12",
"verified": "14"
},
"esmodules": [
"scripts/api.js"
],
"styles": [
"styles/dragonroll.css"
]
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,43 +0,0 @@
/* Dice widgets in the journal pages the module writes from the campaign's notes. */
.dragonroll-note-roll {
display: inline-flex;
align-items: center;
gap: 0.35em;
vertical-align: middle;
cursor: pointer;
}
.dragonroll-note-roll > i {
pointer-events: none;
}
.dragonroll-note-roll-block {
display: flex;
width: 100%;
justify-content: center;
margin: 0.25em 0;
}
/* A `[[Name]]` the world has no document for: the note still reads, but the name
cannot be opened. Resolved links and embeds are Foundry content links/embeds. */
.dragonroll-note-link.is-unresolved {
opacity: 0.65;
text-decoration: underline dashed;
cursor: help;
}
/* The connection window the module settings open: the sign-up link and its actions. */
.dragonroll-pairing-menu {
display: flex;
flex-direction: column;
gap: 10px;
}
.dragonroll-pairing-menu input[readonly] {
width: 100%;
}
.dragonroll-pairing-actions {
display: flex;
gap: 8px;
}

View File

@@ -38,9 +38,6 @@ WORKDIR /app
# Copy built output
COPY --from=builder /app/frontend/.output ./.output
# Source of the Foundry module, zipped on demand by /foundry/dragonroll-foundry.zip
COPY dragonroll-foundry ./dragonroll-foundry
# Expose Nuxt port
EXPOSE 3000

View File

@@ -1,302 +0,0 @@
<script setup>
// `![[Name]]` in a note mounts this card where the token was written. It resolves the label against
// the campaign's lists and draws the character's sheet or the item's description inline; the button
// opens the full sheet window, the same one the sidebar uses. Mounted like a widget: its only prop
// is the label the note wrote, and it talks to the services on its own.
import { computed, nextTick, onMounted, ref } from 'vue';
import { getBaseUrl } from '~/services/Server';
import { FindLinkTarget } from '~/services/LinkAutocomplete';
import { LoadLinkEntry, LoadLinkTargets } from '~/services/LinkTargets';
import { useCampaignService } from '~/services/Campaign';
import { ClearWindow, CreateWindow, GetFirstWindowId } from '~/services/Windows';
// `t` comes from the note as a prop: a card mounted with its own `createApp` is not inside the
// app's plugin tree, so it cannot call `useI18n()` the way the note can.
const props = defineProps(['href', 't']);
const { Campaign } = useCampaignService();
const translate = (key) => (props.t ? props.t(key) : key);
const target = ref(null);
const entry = ref(null);
const loading = ref(true);
const campaignId = computed(() => Campaign.value?._id ?? Campaign.value?.id ?? null);
const isActor = computed(() => target.value?.type === 'actor');
const isItem = computed(() => target.value?.type === 'item');
onMounted(async () => {
const targets = await LoadLinkTargets(campaignId.value);
const found = FindLinkTarget(targets, props.href);
if (!found) {
loading.value = false;
return;
}
target.value = found;
entry.value = await LoadLinkEntry(campaignId.value, found.type, found.id);
loading.value = false;
});
// --- The character sheet, in the small ---
const abilityStats = [
{ key: 'str', label: 'STR' }, { key: 'dex', label: 'DEX' }, { key: 'con', label: 'CON' },
{ key: 'int', label: 'INT' }, { key: 'wis', label: 'WIS' }, { key: 'cha', label: 'CHA' }
];
function abilityModifier(score) {
const modifier = Math.floor((Number(score ?? 10) - 10) / 2);
return modifier >= 0 ? `+${modifier}` : String(modifier);
}
function barPercent(current, max) {
const top = Number(max) || 0;
return top > 0 ? Math.min(100, Math.max(0, ((Number(current) || 0) / top) * 100)) : 0;
}
const hitPointsPercent = computed(() => barPercent(entry.value?.hitPoints?.current, entry.value?.hitPoints?.max));
const actorLine = computed(() => {
const parts = [];
if (entry.value?.className) parts.push(entry.value.className);
if (entry.value?.species) parts.push(entry.value.species);
if (entry.value?.level) parts.push(`${translate('campaigns.character-sheet.level')} ${entry.value.level}`);
return parts.join(' · ');
});
// Uploaded images are served by `/api/public`; a synced world hands over full URLs.
function resolveImage(image) {
if (!image) return '';
return /^(https?:|data:|\/\/)/i.test(image)
? image
: `${getBaseUrl()}/public/${image}`;
}
const imageUrl = computed(() => resolveImage(entry.value?.image));
const initial = computed(() => String(entry.value?.name ?? '?').slice(0, 1).toUpperCase());
// --- The item's sheet, in the small ---
const itemTags = computed(() => {
const parts = [];
if (entry.value?.category) parts.push(translate(`campaigns.item.categories.${entry.value.category}`));
if (entry.value?.rarity) parts.push(translate(`campaigns.item.rarities.${entry.value.rarity}`));
return parts;
});
const weight = computed(() => {
if (entry.value?.weight === undefined || entry.value?.weight === '') return '';
return Number(entry.value.weight).toFixed(1);
});
async function openSheet() {
const type = target.value?.type;
if ((type !== 'actor' && type !== 'item') || !entry.value) return;
const windowType = type === 'actor' ? 'character_sheet' : 'item_sheet';
const existingWindowId = GetFirstWindowId(windowType);
if (existingWindowId !== undefined) {
ClearWindow({ id: existingWindowId });
await nextTick();
}
CreateWindow(windowType, type === 'actor' ? { actor: entry.value } : { item: entry.value });
}
</script>
<template>
<span v-if="loading" class="embedded-entry embedded-loading">{{ href }}</span>
<span v-else-if="entry && isActor" class="embedded-entry embedded-actor">
<span class="embed-head">
<span class="embed-mark" :class="{ empty: !imageUrl }">
<img v-if="imageUrl" :src="imageUrl" alt="">
<span v-else aria-hidden="true">{{ initial }}</span>
</span>
<span class="embed-identity">
<strong class="embed-name">{{ entry.name }}</strong>
<span class="embed-line">{{ actorLine }}</span>
</span>
<button class="embed-open" type="button" @click="openSheet">
{{ translate('campaigns.link-preview.open-character') }}
</button>
</span>
</span>
<span v-else-if="entry && isItem" class="embedded-entry embedded-item">
<span class="embed-head">
<span class="embed-mark" :class="{ empty: !imageUrl }">
<img v-if="imageUrl" :src="imageUrl" alt="">
<span v-else aria-hidden="true">{{ initial }}</span>
</span>
<span class="embed-identity">
<strong class="embed-name">{{ entry.name }}</strong>
<span class="embed-tags">
<span v-for="tag in itemTags" :key="tag" class="embed-tag">{{ tag }}</span>
</span>
</span>
<button class="embed-open" type="button" @click="openSheet">
{{ translate('campaigns.link-preview.open-item') }}
</button>
</span>
</span>
<span v-else class="embedded-entry embedded-missing" :title="translate('campaigns.link-preview.not-found')">{{ href }}</span>
</template>
<style scoped>
/* A card written between paragraphs: it takes the note's width but is still inline content, so the
markdown paragraph around it does not turn into an invalid block. */
.embedded-entry {
display: inline-block;
width: 100%;
margin: 8px 0;
padding: 13px 14px;
box-sizing: border-box;
border: 1px solid var(--color-border);
border-radius: 10px;
background: var(--color-background-light);
box-shadow: 0 3px 12px var(--color-window-shadow);
color: var(--color-text);
font-size: 13px;
vertical-align: top;
}
.embedded-loading,
.embedded-missing {
color: var(--color-gray);
font-size: 12px;
opacity: .75;
}
.embed-head {
display: flex;
align-items: center;
gap: 11px;
border-bottom: 1px solid var(--color-border);
}
.embed-mark {
width: 52px;
height: 52px;
flex: 0 0 52px;
display: grid;
place-items: center;
overflow: hidden;
border: 1px solid var(--color-border);
border-radius: 9px;
background: var(--color-background-soft);
color: var(--color-link);
font: 24px MrEavesRemake;
}
.embed-mark.empty { border-style: dashed; }
.embed-mark img { width: 100%; height: 100%; object-fit: contain; }
.embed-identity { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 5px; }
.embed-name {
font: 21px MrEavesRemake;
letter-spacing: .02em;
overflow-wrap: anywhere;
}
.embed-line { font-size: 11px; opacity: .72; overflow-wrap: anywhere; }
.embed-weight { display: block; margin: 0 0 10px; }
.embed-tags { display: flex; flex-wrap: wrap; gap: 5px; }
.embed-tag {
padding: 2px 8px;
border: 1px solid var(--color-border);
border-radius: 999px;
background: var(--color-background-soft);
font-size: 11px;
opacity: .9;
}
.embed-open {
flex: 0 0 auto;
padding: 6px 10px;
border: 1px solid var(--color-link);
border-radius: 7px;
background: transparent;
color: var(--color-link);
font: inherit;
font-size: 11px;
cursor: pointer;
white-space: nowrap;
}
.embed-open:hover { background: var(--color-button-hover); }
.embed-vitals { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 6px; }
.embed-stat {
display: flex;
flex-direction: column;
align-items: center;
gap: 3px;
padding: 7px 4px;
border: 1px solid var(--color-border);
border-radius: 7px;
background: var(--color-background-soft);
text-align: center;
}
.embed-stat span { font-size: 9px; text-transform: uppercase; letter-spacing: .05em; opacity: .68; }
.embed-stat strong { font: 16px MrEavesRemake; white-space: nowrap; }
.embed-hp-track {
display: block;
height: 6px;
margin: 8px 0 10px;
overflow: hidden;
border-radius: 999px;
background: var(--color-background-soft);
}
.embed-hp-fill { display: block; height: 100%; border-radius: inherit; background: var(--color-red); }
.embed-abilities { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 5px; }
.embed-ability {
display: flex;
flex-direction: column;
align-items: center;
gap: 1px;
padding: 6px 3px;
border: 1px solid var(--color-border);
border-radius: 7px;
background: var(--color-background-soft);
text-align: center;
}
.embed-ability > span:first-child { font-size: 9px; font-weight: 700; letter-spacing: .06em; opacity: .68; }
.embed-ability strong { font: 17px MrEavesRemake; }
.embed-ability em { font-style: normal; font-size: 10px; opacity: .72; }
.embed-section { display: block; margin-top: 10px; }
.embed-section-title {
display: block;
padding-bottom: 5px;
margin-bottom: 5px;
border-bottom: 1px solid var(--color-border);
font: 14px MrEavesRemake;
letter-spacing: .03em;
}
.embed-copy {
display: -webkit-box;
-webkit-line-clamp: 5;
-webkit-box-orient: vertical;
overflow: hidden;
white-space: pre-wrap;
overflow-wrap: anywhere;
line-height: 1.45;
opacity: .85;
}
@media (max-width: 520px) {
.embed-head { align-items: flex-start; flex-wrap: wrap; }
.embed-open { margin-left: auto; }
.embed-abilities { grid-template-columns: repeat(3, minmax(0, 1fr)); }
}
</style>

View File

@@ -1,227 +0,0 @@
<script setup>
// The small card a note shows when the pointer rests on a `[[…]]` link to a character or an item.
// It only reads what the sidebar lists already answer with; pressing the card's button opens the
// full sheet window, the same one clicking the sidebar row opens.
import { computed } from 'vue';
import { useI18n } from 'vue-i18n';
import { getBaseUrl } from '~/services/Server';
const props = defineProps(['preview']);
const emit = defineEmits(['enter', 'leave', 'close', 'open']);
const { t } = useI18n();
const target = computed(() => props.preview?.target ?? {});
const entry = computed(() => props.preview?.entry ?? {});
const isActor = computed(() => target.value.type === 'actor');
const isItem = computed(() => target.value.type === 'item');
const position = computed(() => ({
left: `${props.preview?.x ?? 0}px`,
top: `${props.preview?.y ?? 0}px`
}));
// Uploaded images are served by `/api/public`; a synced world hands over full URLs.
function resolveImage(image) {
if (!image) return '';
return /^(https?:|data:|\/\/)/i.test(image)
? image
: `${getBaseUrl()}/public/${image}`;
}
const imageUrl = computed(() => resolveImage(entry.value.image));
const initial = computed(() => String(entry.value.name ?? '?').slice(0, 1).toUpperCase());
const actorLine = computed(() => {
const parts = [];
if (entry.value.className) parts.push(entry.value.className);
if (entry.value.species) parts.push(entry.value.species);
if (entry.value.level) parts.push(`${t('campaigns.character-sheet.level')} ${entry.value.level}`);
return parts.join(' · ');
});
const itemLine = computed(() => {
const parts = [];
if (entry.value.category) parts.push(t(`campaigns.item.categories.${entry.value.category}`));
if (entry.value.rarity) parts.push(t(`campaigns.item.rarities.${entry.value.rarity}`));
return parts.join(' · ');
});
const hitPoints = computed(() => {
const hp = entry.value.hitPoints;
if (!hp) return '';
return `${Number(hp.current ?? 0)} / ${Number(hp.max ?? 0)}`;
});
const description = computed(() => String(entry.value.description ?? '').trim());
const openLabel = computed(() => t(isActor.value
? 'campaigns.link-preview.open-character'
: 'campaigns.link-preview.open-item'));
</script>
<template>
<Teleport to="body">
<div
class="link-preview"
:style="position"
role="dialog"
:aria-label="entry.name"
@mouseenter="emit('enter')"
@mouseleave="emit('leave')"
>
<div class="preview-head">
<div class="preview-mark" :class="{ empty: !imageUrl }">
<img v-if="imageUrl" :src="imageUrl" :alt="''">
<span v-else aria-hidden="true">{{ initial }}</span>
</div>
<div class="preview-identity">
<strong class="preview-name">{{ entry.name }}</strong>
<span class="preview-line">{{ isActor ? actorLine : itemLine }}</span>
</div>
<button class="preview-close" type="button" :aria-label="$t('campaigns.link-preview.close')" @click="emit('close')">×</button>
</div>
<div v-if="isActor" class="preview-stats">
<div class="preview-stat">
<span>{{ $t('campaigns.character-sheet.armor-class') }}</span>
<strong>{{ entry.armorClass ?? '—' }}</strong>
</div>
<div class="preview-stat">
<span>{{ $t('campaigns.character-sheet.hit-points') }}</span>
<strong>{{ hitPoints || '—' }}</strong>
</div>
<div class="preview-stat">
<span>{{ $t('campaigns.character-sheet.speed') }}</span>
<strong>{{ entry.speed ?? '—' }}</strong>
</div>
</div>
<template v-else-if="isItem">
<p class="preview-copy">{{ description || $t('campaigns.link-preview.no-description') }}</p>
<p v-if="entry.weight !== undefined && entry.weight !== ''" class="preview-weight">
{{ $t('campaigns.item.weight') }}: {{ Number(entry.weight).toFixed(1) }}
</p>
</template>
<button class="preview-open" type="button" @click="emit('open')">{{ openLabel }}</button>
</div>
</Teleport>
</template>
<style scoped>
/* The card floats above the notes, which scroll under it, so it is fixed to the viewport and
positioned from the link's rectangle by Note.vue. */
.link-preview {
position: fixed;
z-index: 4000;
width: 320px;
max-height: min(70vh, 420px);
overflow: auto;
padding: 13px 14px 12px;
box-sizing: border-box;
border: 1px solid var(--color-border);
border-radius: 10px;
background: var(--color-background-light);
box-shadow: 0 10px 30px var(--color-window-shadow);
color: var(--color-text);
font-size: 13px;
}
.preview-head {
display: flex;
align-items: center;
gap: 10px;
padding-bottom: 10px;
margin-bottom: 10px;
border-bottom: 1px solid var(--color-border);
}
.preview-mark {
width: 44px;
height: 44px;
flex: 0 0 44px;
display: grid;
place-items: center;
overflow: hidden;
border: 1px solid var(--color-border);
border-radius: 9px;
background: var(--color-background-soft);
color: var(--color-link);
font: 21px MrEavesRemake;
}
.preview-mark.empty { border-style: dashed; }
.preview-mark img { width: 100%; height: 100%; object-fit: contain; }
.preview-identity { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 3px; }
.preview-name {
font: 18px MrEavesRemake;
letter-spacing: .02em;
overflow-wrap: anywhere;
}
.preview-line { font-size: 11px; opacity: .72; overflow-wrap: anywhere; }
.preview-close {
flex: 0 0 auto;
width: 22px;
height: 22px;
padding: 0;
border: 0;
border-radius: 5px;
background: transparent;
color: var(--color-text);
font-size: 18px;
line-height: 1;
cursor: pointer;
}
.preview-close:hover { background: var(--color-button-hover); }
.preview-stats { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 7px; }
.preview-stat {
display: flex;
flex-direction: column;
align-items: center;
gap: 3px;
padding: 7px 4px;
border: 1px solid var(--color-border);
border-radius: 7px;
background: var(--color-background-soft);
text-align: center;
}
.preview-stat span { font-size: 9px; text-transform: uppercase; letter-spacing: .05em; opacity: .68; }
.preview-stat strong { font: 15px MrEavesRemake; white-space: nowrap; }
.preview-copy {
margin: 0;
display: -webkit-box;
-webkit-line-clamp: 5;
-webkit-box-orient: vertical;
overflow: hidden;
white-space: pre-wrap;
overflow-wrap: anywhere;
line-height: 1.45;
opacity: .85;
}
.preview-weight { margin: 7px 0 0; font-size: 11px; opacity: .68; }
.preview-open {
width: 100%;
margin-top: 11px;
padding: 7px 10px;
border: 1px solid var(--color-link);
border-radius: 7px;
background: transparent;
color: var(--color-link);
font: inherit;
font-size: 12px;
cursor: pointer;
}
.preview-open:hover { background: var(--color-button-hover); }
</style>

View File

@@ -1,21 +1,12 @@
<script setup>
import { onMounted, onUnmounted, ref, nextTick, createApp } from 'vue';
import { onMounted, onUnmounted, ref, createApp } from 'vue';
import ToastManager from '~/components/managers/ToastManager.vue';
import { emitter } from '~/services/Emitter';
import { GetWidget, GetWidgetRegistry, ParseMarkdown } from '~/services/Marker';
import { BuildWidgetSuggestions, FilterWidgetSuggestions, FindWidgetTrigger, InsertWidgetSuggestion } from '~/services/WidgetAutocomplete';
import { FilterLinkSuggestions, FindLinkTarget, FindLinkTrigger, InsertLinkSuggestion } from '~/services/LinkAutocomplete';
import { LoadLinkEntry, LoadLinkTargets } from '~/services/LinkTargets';
import { AnchorMap } from '~/services/Content';
import { ClearWindow, CreateWindow, GetFirstWindowId } from '~/services/Windows';
import { useCampaignService } from '~/services/Campaign';
import { GetWidget, ParseMarkdown } from '~/services/Marker';
import Server from '~/services/Server';
import { DisplayToast } from '~/services/Toaster';
import { useI18n } from 'vue-i18n';
import TestWidget from '../widgets/TestWidget.vue';
import EmbeddedEntry from './EmbeddedEntry.vue';
import LinkPreview from './LinkPreview.vue';
import SuggestionMenu from './SuggestionMenu.vue';
// import { GetNote, GetContent } from '@/services/Content';
const props = defineProps(['text', 'title', 'noteKey']);
@@ -33,228 +24,6 @@ const showClose = ref(false);
let savedState = { text: '', title: '' };
// --- Autocompletat de la nota ---
// Mentre s'edita, escriure `@` ofereix els widgets de la nota (els de Marker.js) i `[[` els
// enllacos de la campanya (notes, actors, objectes i mapes). La llista es calcula sobre el text i
// el cursor reals, no sobre el model, perque l'esdeveniment d'entrada arriba abans que Vue
// actualitzi `sourceText`.
const editor = ref(null);
const suggestions = ref([]);
const selectedSuggestion = ref(0);
const suggestionStyle = ref({});
const allWidgetSuggestions = BuildWidgetSuggestions(GetWidgetRegistry());
const { Campaign } = useCampaignService();
const linkTargets = ref([]);
let linkTargetsLoaded = false;
let linkTargetsRequest = null;
const campaignId = computed(() => Campaign.value?._id ?? Campaign.value?.id ?? null);
// Les destinacions d'enllac venen del servidor una sola vegada: tant el desplegable d'edicio com la
// vista previa dels enllacos ja escrits fan servir la mateixa llista.
function ensureLinkTargets() {
if (linkTargetsLoaded) return Promise.resolve(linkTargets.value);
if (!linkTargetsRequest) {
linkTargetsRequest = LoadLinkTargets(campaignId.value).then((targets) => {
linkTargets.value = targets;
linkTargetsLoaded = true;
return targets;
}).catch(() => []);
}
return linkTargetsRequest;
}
// Estils que el mirall ha de copiar del textarea per mesurar-hi el cursor.
const MIRROR_STYLES = [
'direction', 'boxSizing', 'width', 'height',
'overflowX', 'overflowY',
'borderTopWidth', 'borderRightWidth', 'borderBottomWidth', 'borderLeftWidth',
'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft',
'fontStyle', 'fontVariant', 'fontWeight', 'fontStretch', 'fontSize', 'fontSizeAdjust',
'lineHeight', 'fontFamily', 'textAlign', 'textTransform', 'textIndent',
'textDecoration', 'letterSpacing', 'wordSpacing', 'tabSize'
];
// Posicio (en px, relativa al contenidor de la nota) del cursor del textarea. Un element mirall
// invisible copia els estils i el text fins al cursor i ens diu on cau.
function caretCoordinates(textarea, position) {
const style = window.getComputedStyle(textarea);
const mirror = document.createElement('div');
mirror.style.position = 'absolute';
mirror.style.top = '0';
mirror.style.left = '0';
mirror.style.visibility = 'hidden';
mirror.style.whiteSpace = 'pre-wrap';
mirror.style.wordWrap = 'break-word';
for (const property of MIRROR_STYLES) {
if (style[property] != null) mirror.style[property] = style[property];
}
const value = textarea.value;
mirror.textContent = value.substring(0, position);
const marker = document.createElement('span');
marker.textContent = value.substring(position) || '.';
mirror.appendChild(marker);
document.body.appendChild(mirror);
const lineHeight = parseFloat(style.lineHeight) || parseFloat(style.fontSize) * 1.2 || 20;
const coordinates = {
top: marker.offsetTop + textarea.offsetTop - textarea.scrollTop,
left: marker.offsetLeft + textarea.offsetLeft - textarea.scrollLeft,
lineHeight
};
document.body.removeChild(mirror);
return coordinates;
}
// Cada entrada del desplegable porta ja el seu text i la seva pista traduida; `value` es el widget o
// l'objectiu d'enllac cru que s'inserirà en triar-la.
function widgetEntry(widget) {
return {
key: `widget:${widget.type}:${widget.name}`,
kind: 'widget',
value: widget,
label: `@${widget.name}`,
hint: t('general.widgets.' + widget.type)
};
}
function linkEntry(target) {
return {
key: `link:${target.type}:${target.id}`,
kind: 'link',
value: target,
label: `[[${target.label}]]`,
hint: t(`campaigns.sections.${target.type}s`)
};
}
function closeSuggestions() {
suggestions.value = [];
}
// Dibuixa el desplegable sota el cursor, girant-lo cap amunt si no hi cap.
function showSuggestions(matches, caret) {
if (!matches.length || !editor.value) {
closeSuggestions();
return;
}
suggestions.value = matches;
selectedSuggestion.value = 0;
const coordinates = caretCoordinates(editor.value, caret);
const container = editor.value.parentElement;
const containerHeight = container ? container.clientHeight : 0;
let top = coordinates.top + coordinates.lineHeight;
if (containerHeight && top + 150 > containerHeight) top = Math.max(0, coordinates.top - 150);
suggestionStyle.value = { top: `${top}px`, left: `${coordinates.left}px` };
}
function updateSuggestions(text, caret) {
const widgetTrigger = FindWidgetTrigger(text, caret);
if (widgetTrigger) {
showSuggestions(FilterWidgetSuggestions(allWidgetSuggestions, widgetTrigger.query).map(widgetEntry), caret);
return;
}
const linkTrigger = FindLinkTrigger(text, caret);
if (linkTrigger) {
// Les destinacions d'enllac vénen del servidor: la primera vegada que es tecleja `[[` es
// demanen, i en arribar es torna a calcular el desplegable sobre el que hi ha ara al cursor.
if (!linkTargetsLoaded) {
closeSuggestions();
ensureLinkTargets().then(() => {
const el = editor.value;
if (el) updateSuggestions(el.value, el.selectionStart ?? el.value.length);
});
return;
}
showSuggestions(FilterLinkSuggestions(linkTargets.value, linkTrigger.query).map(linkEntry), caret);
return;
}
closeSuggestions();
}
function onEditorInput(event) {
const el = event.target;
updateSuggestions(el.value, el.selectionStart ?? el.value.length);
}
function onEditorClick(event) {
if (!suggestions.value.length) return;
const el = event.target;
updateSuggestions(el.value, el.selectionStart ?? el.value.length);
}
function onEditorKeydown(event) {
if (!suggestions.value.length) return;
if (event.key === 'ArrowDown') {
event.preventDefault();
selectedSuggestion.value = (selectedSuggestion.value + 1) % suggestions.value.length;
} else if (event.key === 'ArrowUp') {
event.preventDefault();
selectedSuggestion.value = (selectedSuggestion.value - 1 + suggestions.value.length) % suggestions.value.length;
} else if (event.key === 'Enter' || event.key === 'Tab') {
event.preventDefault();
applySuggestion(suggestions.value[selectedSuggestion.value]);
} else if (event.key === 'Escape') {
event.preventDefault();
closeSuggestions();
}
}
function onSuggestionHover(index) {
selectedSuggestion.value = index;
}
function applySuggestion(entry) {
if (!entry) return;
if (entry.kind === 'link') applyLinkSuggestion(entry.value);
else applyWidgetSuggestion(entry.value);
}
// Escriu el text inserit i deixa el cursor on el widget o l'enllac el volen.
function writeSuggestion(result) {
sourceText.value = result.text;
closeSuggestions();
const el = editor.value;
if (!el) return;
nextTick(() => {
el.focus();
el.setSelectionRange(result.caret, result.caret);
});
}
function applyWidgetSuggestion(suggestion) {
const el = editor.value;
if (!el || !suggestion) return;
const trigger = FindWidgetTrigger(el.value, el.selectionStart ?? el.value.length);
if (!trigger) {
closeSuggestions();
return;
}
writeSuggestion(InsertWidgetSuggestion(el.value, trigger, suggestion));
}
function applyLinkSuggestion(target) {
const el = editor.value;
if (!el || !target) return;
const trigger = FindLinkTrigger(el.value, el.selectionStart ?? el.value.length);
if (!trigger) {
closeSuggestions();
return;
}
writeSuggestion(InsertLinkSuggestion(el.value, trigger, target));
}
function markDirty() {
isDirty.value = sourceText.value !== savedState.text || title.value !== savedState.title;
}
@@ -312,195 +81,6 @@ function mountComponents() {
});
});
}
// --- Enllacos `[[…]]` de la vista previa ---
// Cada enllac porta el nom de l'entrada. En muntar la nota el resolem contra les llistes de la
// campanya: un personatge o un objecte mostra una fitxa resumida en passar-hi el ratoli i s'obre
// sencer en fer-hi clic; una nota s'obre a la columna i un mapa s'ancora com des de la barra.
const linkPreview = ref(null);
const PREVIEW_DELAY = 180;
const PREVIEW_HIDE_DELAY = 140;
let previewTimer = null;
let previewHideTimer = null;
let hoveredLink = null;
let previewHovered = false;
function resolveLink(el) {
return FindLinkTarget(linkTargets.value, el?.dataset?.href);
}
function hideLinkPreview() {
clearTimeout(previewTimer);
clearTimeout(previewHideTimer);
previewHovered = false;
hoveredLink = null;
linkPreview.value = null;
}
function scheduleHideLinkPreview() {
clearTimeout(previewTimer);
clearTimeout(previewHideTimer);
previewHideTimer = setTimeout(() => {
if (!previewHovered) hideLinkPreview();
}, PREVIEW_HIDE_DELAY);
}
function keepLinkPreview() {
previewHovered = true;
clearTimeout(previewHideTimer);
}
async function showLinkPreview(el) {
await ensureLinkTargets();
if (hoveredLink !== el) return;
const target = resolveLink(el);
if (!target || (target.type !== 'actor' && target.type !== 'item')) return;
const entry = await LoadLinkEntry(campaignId.value, target.type, target.id);
if (!entry || hoveredLink !== el) return;
// The card is fixed to the viewport, so it is placed from the link's rectangle and kept
// inside the window; a link near the bottom gets the card above it instead.
const rect = el.getBoundingClientRect();
const width = 320;
const estimatedHeight = 260;
const x = Math.min(Math.max(8, rect.left), Math.max(8, window.innerWidth - width - 12));
const y = rect.bottom + estimatedHeight + 12 > window.innerHeight
? Math.max(8, rect.top - estimatedHeight - 8)
: rect.bottom + 8;
linkPreview.value = { target, entry, x, y };
}
function onLinkEnter(el) {
hoveredLink = el;
clearTimeout(previewTimer);
clearTimeout(previewHideTimer);
previewTimer = setTimeout(() => showLinkPreview(el), PREVIEW_DELAY);
}
// Marks every link of the rendered note with the type it points at, so the CSS can tell a character
// from an item and a target that is gone can be dimmed. It runs after the lists arrive.
async function annotateLinks(root) {
const links = Array.from(root.querySelectorAll('.vue-link'));
if (!links.length) return;
await ensureLinkTargets();
if (!root.isConnected) return;
for (const el of links) {
const target = resolveLink(el);
if (target) {
el.dataset.linkType = target.type;
el.classList.add('is-resolved');
} else {
el.classList.add('is-unresolved');
el.title = t('campaigns.link-preview.not-found');
}
}
}
function bindLinks(root) {
root.querySelectorAll('.vue-link').forEach((el) => {
if (el.dataset.linkBound) return;
el.dataset.linkBound = '1';
el.addEventListener('mouseenter', () => onLinkEnter(el));
el.addEventListener('mouseleave', scheduleHideLinkPreview);
el.addEventListener('focus', () => onLinkEnter(el));
el.addEventListener('blur', scheduleHideLinkPreview);
el.addEventListener('click', (event) => {
event.stopPropagation();
openLink(el);
});
el.addEventListener('keydown', (event) => {
if (event.key !== 'Enter' && event.key !== ' ') return;
event.preventDefault();
event.stopPropagation();
openLink(el);
});
});
annotateLinks(root);
}
async function openLink(el) {
await ensureLinkTargets();
const target = resolveLink(el);
if (!target) return;
hideLinkPreview();
openLinkTarget(target);
}
async function openLinkTarget(target) {
if (target.type === 'actor' || target.type === 'item') {
const entry = await LoadLinkEntry(campaignId.value, target.type, target.id);
if (entry) await openEntrySheet(target.type, entry);
return;
}
if (target.type === 'note') {
try {
const response = await Server().get(`/note/retrieve/${target.id}`);
if (response.data.status !== 'ok' || !response.data.note) return;
const note = response.data.note;
emitter.emit('push-note', { key: note._id, title: note.title, text: note.content ?? '', date: note.date });
} catch (error) {}
return;
}
if (target.type === 'map') {
const map = await LoadLinkEntry(campaignId.value, 'map', target.id);
if (map) AnchorMap(map);
}
}
// The same window the sidebar opens: replace the sheet that is already up instead of stacking a
// second one.
async function openEntrySheet(type, entry) {
const windowType = type === 'actor' ? 'character_sheet' : 'item_sheet';
const existingWindowId = GetFirstWindowId(windowType);
if (existingWindowId !== undefined) {
ClearWindow({ id: existingWindowId });
await nextTick();
}
CreateWindow(windowType, type === 'actor' ? { actor: entry } : { item: entry });
}
function openPreviewedEntry() {
const target = linkPreview.value?.target;
hideLinkPreview();
if (target) openLinkTarget(target);
}
function setupLinks() {
const root = renderedContent.value;
if (!root) return;
bindLinks(root);
}
// --- `![[…]]` embeddings ---
// An embedded token mounts a card of its own, the way widgets do: the placeholder left by Marker is
// the app's container, and `EmbeddedEntry.vue` resolves the label and draws the sheet inline.
function mountEmbeds() {
const root = renderedContent.value;
if (!root) return;
root.querySelectorAll('.vue-embed').forEach(el => {
if (el.dataset.embedMounted) return;
el.dataset.embedMounted = '1';
try {
const app = createApp(EmbeddedEntry, { href: el.dataset.href, t });
app.config.errorHandler = (err) => {
console.error('Embed error', el.dataset.href, err);
};
app.mount(el);
mountedApps.push(app);
} catch (err) {
console.error('Failed to mount embed', el.dataset.href, err);
}
});
}
///
function update(){
@@ -508,14 +88,11 @@ function update(){
// la reassignacio de displayText (v-html) eliminaria els contenidors i
// desmuntar-les despres fallaria sobre nodes desaccelats.
unmountComponents();
hideLinkPreview();
displayText.value = compiledMarkdown.value;
setTimeout(() => {
setupHeadings();
setupCallout()
setupLinks();
mountComponents();
mountEmbeds();
}, 0);
}
@@ -530,9 +107,6 @@ onMounted(() => {
savedState = { text: props.text, title: props.title };
emitter.on('title-updated', handleTitleUpdate);
// window.addEventListener('keydown', handleKeydown);
// The preview is pinned to the viewport, so any scroll (the note column, another note) leaves
// it behind: dismiss it instead of letting it float over the wrong place.
window.addEventListener('scroll', hideLinkPreview, true);
setTimeout(() => setupCallout(), 0);
update();
});
@@ -546,8 +120,6 @@ function handleTitleUpdate(data) {
onUnmounted(() => {
emitter.off('title-updated', handleTitleUpdate);
// window.removeEventListener('keydown', handleKeydown);
window.removeEventListener('scroll', hideLinkPreview, true);
hideLinkPreview();
unmountComponents();
});
@@ -556,8 +128,6 @@ function handleKeydown(e) {
if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'e') {
e.preventDefault(); // prevent browser default behavior
editingMode.value = !editingMode.value;
closeSuggestions();
hideLinkPreview();
if(!editingMode.value){
update();
SaveNote(); // Save when switching to display mode
@@ -710,7 +280,7 @@ function renderFoldTree(items, target) {
function handleFoldClick(e) {
// No plegar quan es fa clic en un enllaç o se selecciona text
if (e.target.closest('a, .vue-link')) return;
if (e.target.closest('a')) return;
const selection = window.getSelection();
if (selection && selection.toString()) return;
@@ -755,39 +325,13 @@ function setupHeadings() {
<span>{{ title }}</span>
</div>
<div class="note-content-container">
<template v-if="editingMode">
<textarea
ref="editor"
v-model="sourceText"
class="full-editor"
@input="onEditorInput"
@click="onEditorClick"
@keydown="onEditorKeydown"
@blur="closeSuggestions"
></textarea>
<SuggestionMenu
v-if="suggestions.length"
:suggestions="suggestions"
:selected="selectedSuggestion"
:position="suggestionStyle"
@select="applySuggestion"
@hover="onSuggestionHover"
/>
</template>
<textarea v-model="sourceText" class="full-editor" v-if="editingMode"></textarea>
<div v-else class="note-content" ref="noteContent">
<h1>{{ title }}</h1>
<div ref="renderedContent" v-html="displayText"></div>
</div>
</div>
<LinkPreview
v-if="linkPreview"
:preview="linkPreview"
@enter="keepLinkPreview"
@leave="scheduleHideLinkPreview"
@close="hideLinkPreview"
@open="openPreviewedEntry"
/>
</div>
</template>
@@ -895,7 +439,6 @@ width: 100%;
.note-content-container {
width: 100%;
position: relative;
}
.note-content :deep(img) {
@@ -903,29 +446,4 @@ width: 100%;
height: auto;
display: block; /* optional: avoids inline spacing issues */
}
/* Els `[[enllacos]]` de la nota: es llegeixen com a text subratllat i obren la fitxa de
l'entrada. El tipus el marca el servei d'enllacos en resoldre'l. */
.note-content :deep(.vue-link) {
color: var(--color-link);
cursor: pointer;
text-decoration: underline;
text-decoration-style: dotted;
text-underline-offset: 2px;
border-radius: 2px;
}
.note-content :deep(.vue-link:hover),
.note-content :deep(.vue-link:focus-visible) {
text-decoration-style: solid;
background: var(--color-button-hover);
outline: none;
}
.note-content :deep(.vue-link.is-unresolved) {
color: var(--color-gray);
cursor: help;
text-decoration-style: dashed;
opacity: .7;
}
</style>

View File

@@ -1,73 +0,0 @@
<script setup>
// The dropdown the note editor shows while a widget name or a wiki link is being typed. It only
// draws what it is handed: each entry carries its own `label` and `hint`, and the parent decides
// when it is open, where it sits and what is selected.
defineProps(['suggestions', 'selected', 'position']);
const emit = defineEmits(['select', 'hover']);
</script>
<template>
<div class="suggestion-menu" :style="position" role="listbox">
<div
v-for="(suggestion, index) in suggestions"
:key="suggestion.key"
class="suggestion"
:class="{ selected: index === selected }"
role="option"
:aria-selected="index === selected"
@mousedown.prevent="emit('select', suggestion)"
@mouseenter="emit('hover', index)"
>
<span class="suggestion-label">{{ suggestion.label }}</span>
<span class="suggestion-hint">{{ suggestion.hint }}</span>
</div>
</div>
</template>
<style scoped>
.suggestion-menu {
position: absolute;
z-index: 40;
min-width: 190px;
max-width: 320px;
max-height: 240px;
overflow-y: auto;
padding: 4px;
display: flex;
flex-direction: column;
gap: 2px;
border: 1px solid var(--color-border);
border-radius: 6px;
background-color: var(--color-background-light);
box-shadow: 0 6px 18px var(--color-container-shadow);
}
.suggestion {
display: flex;
align-items: baseline;
justify-content: space-between;
gap: 12px;
padding: 4px 8px;
border-radius: 4px;
cursor: pointer;
}
.suggestion.selected {
background-color: var(--color-selected);
}
.suggestion-label {
font-family: monospace;
color: var(--color-text);
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.suggestion-hint {
font-size: 11px;
color: var(--color-gray);
white-space: nowrap;
}
</style>

View File

@@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall } from '~/services/MapWalls';
import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter';
@@ -114,6 +115,18 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) {
if (event.button !== 0 || !viewport.value) return;
if (editingWalls.value && imageUrl.value) {
// While the wall editor is open the left pointer draws instead of panning: the wheel and
// the zoom buttons still move the view about.
const spot = wallSpot(event);
const first = spot && SnapToGrid(spot, grid.value);
if (!first) return;
pointerId = event.pointerId;
viewport.value.setPointerCapture?.(event.pointerId);
drawingWall.value = { x1: first.x, y1: first.y, x2: first.x, y2: first.y };
selectedWall.value = null;
return;
}
dragging.value = true;
pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY };
@@ -121,13 +134,28 @@ function onPointerDown(event) {
}
function onPointerMove(event) {
if (drawingWall.value && event.pointerId === pointerId) {
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (snapped) drawingWall.value = { ...drawingWall.value, x2: snapped.x, y2: snapped.y };
return;
}
if (!dragging.value || event.pointerId !== pointerId) return;
pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) };
lastPointer = { x: event.clientX, y: event.clientY };
}
function onPointerUp(event) {
async function onPointerUp(event) {
if (event.pointerId !== pointerId) return;
if (drawingWall.value) {
const segment = drawingWall.value;
pointerId = null;
drawingWall.value = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
// A drag that ended where it started drew no wall; anything with length becomes one.
if (IsWall(segment)) await saveWalls([...walls.value, segment]);
return;
}
dragging.value = false;
pointerId = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
@@ -503,6 +531,215 @@ function handleActorEntry({ entityType, entry }) {
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
}
// --- Walls blocking the map ---
// The wall editor: with walls on, dragging over the map draws a segment from one grid intersection
// to the next, dragging an endpoint retypes it, dragging the segment itself moves it, and right
// clicking one (or Delete on a focused one) opens its controls and takes it off. Walls are stored
// in image pixels like the pins, and every edit saves the whole set — the same set a paired
// Foundry scene takes over, so the two see the same walls.
const walls = computed(() => map.value?.walls ?? []);
const editingWalls = ref(false);
// The wall a pointer is holding: a new segment being dragged, the whole segment being slid, or one
// endpoint being retyped. Like a token's move, the change stays local until the pointer lets go,
// so a drag across the map is one save and not one per mouse move.
const drawingWall = ref(null);
const draggingWall = ref(null);
const draggingEnd = ref(null);
// The wall whose controls are asked for: selected before its menu opens, kept while it is dragged.
const selectedWall = ref(null);
const END_KEYS = [['x1', 'y1'], ['x2', 'y2']];
let wallDragPointerId = null;
let lastWallDrag = { x: 0, y: 0 };
function toggleWallEditing() {
editingWalls.value = !editingWalls.value;
if (!editingWalls.value) {
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
}
}
// The spot of the viewport in image pixels, clamped to the image: while a wall is being held the
// pointer may cross an edge, and the wall should stay on the map rather than vanish.
function wallSpot(event) {
const bounds = viewport.value?.getBoundingClientRect();
if (!bounds) return null;
return ToDrawPoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
}
// The wall as it should be drawn right now: with the drag's preview on top of what is stored.
function wallGeometry(wall) {
if (draggingWall.value && String(draggingWall.value.wall?._id) === String(wall?._id)) {
const moved = MoveWall(wall, draggingWall.value.dx, draggingWall.value.dy);
if (moved) return { ...wall, ...moved };
}
if (draggingEnd.value && String(draggingEnd.value.wall?._id) === String(wall?._id) && draggingEnd.value.point) {
const [keyX, keyY] = END_KEYS[draggingEnd.value.end];
return { ...wall, [keyX]: draggingEnd.value.point.x, [keyY]: draggingEnd.value.point.y };
}
return wall;
}
function wallScreen(wall) {
return ToScreenWall(wallGeometry(wall), viewState());
}
function wallClasses(wall) {
return {
'wall-door': Number(wall?.door) > 0,
'wall-move-only': !wall?.sight && Number(wall?.door) === 0,
selected: Boolean(selectedWall.value) && String(selectedWall.value) === String(wall?._id)
};
}
// The wire shape of a wall: what the server keeps, with the `_id` of the ones it already has so a
// save neither doubles them nor re-ids them under the viewer's feet.
function plainWall(wall) {
const stored = {
x1: Number(wall.x1), y1: Number(wall.y1), x2: Number(wall.x2), y2: Number(wall.y2),
move: wall.move !== false, sight: wall.sight !== false, door: Number(wall.door) || 0
};
return wall._id ? { _id: String(wall._id), ...stored } : stored;
}
async function saveWalls(next) {
return updateMap('/map/walls', { id: map.value?._id, walls: next.map(plainWall) }, t('campaigns.map.walls.error'));
}
async function replaceWall(wall, patch) {
const next = walls.value.map((current) => (
String(current?._id) === String(wall?._id) ? { ...current, ...patch } : current
));
await saveWalls(next);
}
async function removeWall(wall) {
if (String(selectedWall.value) === String(wall?._id)) selectedWall.value = null;
await saveWalls(walls.value.filter((current) => String(current?._id) !== String(wall?._id)));
}
function onWallPointerDown(event, wall) {
// The segment is what is being held here: the map must not start panning under the pointer.
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
lastWallDrag = { x: event.clientX, y: event.clientY };
selectedWall.value = String(wall?._id ?? '');
draggingWall.value = { wall, dx: 0, dy: 0 };
}
function onWallPointerMove(event) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const zoomScale = zoom.value || 1;
draggingWall.value = {
...draggingWall.value,
// The drag is measured in screen pixels and applied in image ones, and the whole segment
// goes by the same delta: a moved wall keeps its shape and the grid it was drawn on.
dx: draggingWall.value.dx + (event.clientX - lastWallDrag.x) / zoomScale,
dy: draggingWall.value.dy + (event.clientY - lastWallDrag.y) / zoomScale
};
lastWallDrag = { x: event.clientX, y: event.clientY };
}
async function onWallPointerUp(event) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const { wall, dx, dy } = draggingWall.value;
wallDragPointerId = null;
draggingWall.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
const moved = MoveWall(wall, dx, dy);
if (!moved || (moved.x1 === Number(wall.x1) && moved.y1 === Number(wall.y1)
&& moved.x2 === Number(wall.x2) && moved.y2 === Number(wall.y2))) return;
await replaceWall(wall, moved);
}
function onWallEndPointerDown(event, wall, end) {
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
selectedWall.value = String(wall?._id ?? '');
draggingEnd.value = { wall, end, point: { x: Number(wall[END_KEYS[end][0]]), y: Number(wall[END_KEYS[end][1]]) } };
}
function onWallEndPointerMove(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (!snapped) return;
draggingEnd.value = { ...draggingEnd.value, point: snapped };
}
async function onWallEndPointerUp(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const { wall, end, point } = draggingEnd.value;
wallDragPointerId = null;
draggingEnd.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
const [keyX, keyY] = END_KEYS[end];
if (point.x === Number(wall[keyX]) && point.y === Number(wall[keyY])) return;
const retyped = { ...wall, [keyX]: point.x, [keyY]: point.y };
// Retyped into its own end, the segment has no length left: the wall is gone.
if (!IsWall(retyped)) await removeWall(wall);
else await replaceWall(wall, { [keyX]: point.x, [keyY]: point.y });
}
function onWallContextMenu(wall) {
selectedWall.value = String(wall?._id ?? '');
ShowContextMenu([
{
name: t(wall.sight ? 'campaigns.map.walls.sight-open' : 'campaigns.map.walls.sight-block'),
icon: '/icons/iconoir/regular/eye.svg',
action: () => { HideContextMenu(); replaceWall(wall, { sight: !wall.sight }); }
},
{
name: t(wall.move ? 'campaigns.map.walls.move-open' : 'campaigns.map.walls.move-block'),
icon: '/icons/iconoir/regular/lock.svg',
action: () => { HideContextMenu(); replaceWall(wall, { move: !wall.move }); }
},
{
name: t('campaigns.map.walls.door'),
icon: '/icons/iconoir/regular/home-simple-door.svg',
context: [
{ name: t('campaigns.map.walls.door-none'), action: () => { HideContextMenu(); replaceWall(wall, { door: 0 }); } },
{ name: t('campaigns.map.walls.door-closed'), action: () => { HideContextMenu(); replaceWall(wall, { door: 2 }); } },
{ name: t('campaigns.map.walls.door-open'), action: () => { HideContextMenu(); replaceWall(wall, { door: 1 }); } }
]
},
{ divider: true },
{
name: t('campaigns.map.walls.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeWall(wall); }
}
]);
}
// A focused wall answers Delete too, the way a focused token does.
async function onWallKeydown(event, wall) {
if (event.key !== 'Delete' && event.key !== 'Backspace') return;
event.preventDefault();
await removeWall(wall);
}
// Escape lets go of whatever the editor is holding: an unfinished segment first, the selection next.
function onWindowKeydown(event) {
if (event.key !== 'Escape') return;
if (drawingWall.value) drawingWall.value = null;
else if (selectedWall.value) selectedWall.value = null;
}
// A different map was anchored while this pane was already mounted.
watch(() => props.map, (incoming, previous) => {
if (incoming === previous) return;
@@ -510,6 +747,10 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 };
movingToken.value = null;
draggingActor.value = false;
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
});
watch(campaignId, () => {
@@ -525,6 +766,7 @@ onMounted(() => {
emitter.on('campaign-entry-updated', handleActorEntry);
emitter.on('delete-note', handlePinnedNoteDeleted);
emitter.on('title-updated', handlePinnedNoteRenamed);
window.addEventListener('keydown', onWindowKeydown);
fetchPinnableNotes();
fetchTokenActors();
});
@@ -535,6 +777,7 @@ onBeforeUnmount(() => {
emitter.off('campaign-entry-updated', handleActorEntry);
emitter.off('delete-note', handlePinnedNoteDeleted);
emitter.off('title-updated', handlePinnedNoteRenamed);
window.removeEventListener('keydown', onWindowKeydown);
});
</script>
@@ -550,6 +793,10 @@ onBeforeUnmount(() => {
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" :class="{ selected: editingWalls }" type="button" :title="$t('campaigns.map.walls.edit')"
:aria-label="$t('campaigns.map.walls.edit')" :aria-pressed="editingWalls.toString()" @click="toggleWallEditing">
<img class="tool-icon" src="/icons/iconoir/regular/border-out.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
</button>
@@ -587,6 +834,42 @@ onBeforeUnmount(() => {
<template v-if="imageUrl">
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
<!-- Walls are drawn in screen space like the pins, so their lines stay thin at any
zoom. They only catch the mouse while the editor is open, and never when there
is no image to hold them. -->
<svg v-if="imageUrl && (walls.length || drawingWall || editingWalls)" class="map-walls" :class="{ editing: editingWalls }">
<g v-for="wall in walls" :key="wall._id">
<line class="wall-line" :class="wallClasses(wall)" v-bind="wallScreen(wall)"></line>
<template v-if="editingWalls">
<line
class="wall-hit"
role="button"
tabindex="0"
:aria-label="$t('campaigns.map.walls.wall')"
v-bind="wallScreen(wall)"
@pointerdown="onWallPointerDown($event, wall)"
@pointermove="onWallPointerMove"
@pointerup="onWallPointerUp"
@pointercancel="onWallPointerUp"
@contextmenu.stop.prevent="onWallContextMenu(wall)"
@keydown="onWallKeydown($event, wall)"
></line>
<circle
v-for="end in [0, 1]"
:key="end"
class="wall-end"
:cx="end === 0 ? wallScreen(wall).x1 : wallScreen(wall).x2"
:cy="end === 0 ? wallScreen(wall).y1 : wallScreen(wall).y2"
r="5"
@pointerdown="onWallEndPointerDown($event, wall, end)"
@pointermove="onWallEndPointerMove"
@pointerup="onWallEndPointerUp"
@pointercancel="onWallEndPointerUp"
></circle>
</template>
</g>
<line v-if="drawingWall" class="wall-draft" v-bind="ToScreenWall(drawingWall, viewState())"></line>
</svg>
<div class="map-pins">
<button
v-for="pin in pins"
@@ -629,6 +912,7 @@ onBeforeUnmount(() => {
</button>
</div>
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
<div v-if="editingWalls" class="map-walls-hint">{{ $t('campaigns.map.walls.hint') }}</div>
</template>
<div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }}
@@ -699,6 +983,27 @@ onBeforeUnmount(() => {
background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
/* Walls are drawn in screen space like the pins, so their lines stay thin at any zoom. A sight
wall is red, a wall that only stops movement grey, a door green — close to how Foundry paints
them on its own scenes. Only the editor's hit lines and handles catch the mouse. */
.map-walls { position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none; overflow: visible; }
.wall-line { stroke: var(--color-red); stroke-width: 2; opacity: .85; pointer-events: none; }
.wall-line.wall-move-only { stroke: var(--color-gray); }
.wall-line.wall-door { stroke: var(--color-green); stroke-width: 3; }
.wall-line.selected { stroke: var(--color-link); opacity: 1; }
/* The grabbable line and the endpoint handles: each wall gives its own hit area, wide enough that
the pointer finds it at any zoom. */
.wall-hit { stroke: transparent; stroke-width: 16; stroke-linecap: round; pointer-events: stroke; cursor: move; }
.wall-hit:focus-visible { stroke: var(--color-link); stroke-opacity: .35; outline: none; }
.wall-end { fill: var(--color-background-soft); stroke: var(--color-link); stroke-width: 1.5; pointer-events: auto; cursor: crosshair; }
.wall-draft { stroke: var(--color-link); stroke-width: 2; stroke-dasharray: 6 4; pointer-events: none; }
/* Shown while the wall editor is open, so the gestures it answers to are at hand. */
.map-walls-hint {
position: absolute; bottom: 10px; left: 50%; transform: translateX(-50%);
padding: 5px 10px; border: 1px dashed var(--color-link); border-radius: 7px;
background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-empty { width: 100%; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; font-size: 13px; opacity: .8; }
.map-edit { border: 1px solid var(--color-border); border-radius: 7px; padding: 6px 11px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px; cursor: pointer; }
.map-edit:hover { background: var(--color-button-hover); }

View File

@@ -1,28 +1,23 @@
<script setup>
import { ref,onMounted,onUnmounted } from 'vue';
import { ref,onMounted } from 'vue';
import { emitter } from '~/services/Emitter';
const statusIcon = ref(null);
const statusMessage = ref(null);
const handleStatusUpdate = (state) => {
emitter.on("status-bar-update", (state) => {
var preloadImage = new Image();
preloadImage.src = '/icons/Pixelarticons/black/' + state.icon + ".svg";
preloadImage.onload = function() {
// The update can arrive (or finish loading) while the bar is not mounted.
if (statusIcon.value) statusIcon.value.src = this.src;
statusIcon.value.src = this.src;
};
if (statusMessage.value) statusMessage.value.innerText = state.text;
};
emitter.on("status-bar-update", handleStatusUpdate);
statusMessage.value.innerText = state.text;
})
onMounted(() => {
emitter.emit("status-bar-update", {text: "Hola", icon: "check"})
});
onUnmounted(() => emitter.off("status-bar-update", handleStatusUpdate));
</script>
<template>
<span class="status-text">

View File

@@ -171,6 +171,7 @@ async function Unlink(service) {
</div>
</template>
<template #integrations>
<p class="help-text standalone">{{ $t('campaigns.settings.services.help') }}</p>
<div class="settings-fields">
<div v-for="service in serviceKeys" :key="service" class="service">
<div class="service-head">

View File

@@ -1,6 +1,6 @@
<script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, CreateWindow, GetFirstWindowId, Top } from '@/services/Windows';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter';
@@ -100,11 +100,6 @@ function normalizeActor(actor) {
name: item.name ?? '', quantity: Number(item.quantity ?? 1), weight: Number(item.weight ?? 0),
icon: item.icon ?? ''
})),
// Les capacitats del món: una filera per element, amb la seva icona. El text lliure
// de sota continua sent el que el món no té com a element.
features: (actor?.features ?? []).map((feature) => ({
name: feature.name ?? '', description: feature.description ?? '', icon: feature.icon ?? ''
})),
traits: actor?.traits ?? '',
spells: actor?.spells ?? '',
image: actor?.image ?? ''
@@ -238,14 +233,6 @@ function removeInventoryItem(index) {
form.value.inventory.splice(index, 1);
}
// Una capacitat s'obre com un objecte: la seva icona, el seu nom i la seva descripció en una
// finestra pròpia. N'hi ha una de sola, i obrir-ne una altra substitueix la que hi ha.
function openTrait(feature) {
const existing = GetFirstWindowId('trait_sheet');
if (existing !== undefined) ClearWindow({ id: existing });
CreateWindow('trait_sheet', { feature });
}
async function saveSheet() {
if (!form.value.name.trim() || saving.value) return;
saving.value = true;
@@ -532,20 +519,8 @@ async function saveSheet() {
<main v-show="activeTab === 'traits'" class="sheet-tab-body">
<section class="sheet-panel traits-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2>
<!-- Una capacitat per filera, amb la icona a l'esquerra com l'inventari;
clicar-la obre la seva descripció. -->
<div v-if="form.features.length" class="trait-list">
<button v-for="(trait, index) in form.features" :key="index" class="trait-row" type="button" @click="openTrait(trait)">
<span class="trait-icon-cell">
<img v-if="trait.icon" :src="resolveImage(trait.icon)" alt="">
<span v-else class="item-icon-blank" aria-hidden="true" />
</span>
<span class="trait-name">{{ trait.name }}</span>
</button>
</div>
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" />
<p v-else-if="form.traits" class="sheet-copy">{{ form.traits }}</p>
<p v-else-if="!form.features.length" class="sheet-copy">{{ $t('campaigns.character-sheet.empty-traits') }}</p>
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p>
</section>
</main>
@@ -661,18 +636,8 @@ async function saveSheet() {
.sheet-copy { min-height: 74px; margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; font-size: 13px; line-height: 1.45; opacity: .85; }
input, textarea { box-sizing: border-box; max-width: 100%; padding: 6px 7px; border: 1px solid var(--color-border); border-radius: 6px; background: var(--color-background-soft); color: var(--color-text); font: inherit; }
input:focus, textarea:focus { outline: none; border-color: var(--color-link); }
input[type='number'] { appearance: textfield; -moz-appearance: textfield; }
input[type='number']::-webkit-inner-spin-button, input[type='number']::-webkit-outer-spin-button { -webkit-appearance: none; margin: 0; }
textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.traits-panel, .spells-panel { min-height: 175px; }
/* Les capacitats de la pestanya de trets: la icona del món a l'esquerra i el nom a la dreta,
com una filera de l'inventari. */
.trait-list { display: flex; flex-direction: column; gap: 5px; margin-bottom: 11px; }
.trait-row { display: flex; align-items: center; gap: 8px; width: 100%; padding: 5px 7px; border: 1px solid var(--color-border); border-radius: 7px; background: var(--color-background-soft); color: var(--color-text); font: inherit; text-align: left; cursor: pointer; }
.trait-row:hover { border-color: var(--color-link); }
.trait-icon-cell { width: 26px; flex: 0 0 26px; display: grid; place-items: center; }
.trait-icon-cell img { display: block; width: 26px; height: 26px; object-fit: contain; border-radius: 5px; }
.trait-name { flex: 1; min-width: 0; overflow-wrap: anywhere; font-size: 13px; }
.panel-title-row { display: flex; justify-content: space-between; align-items: center; gap: 8px; }
.panel-title-row h2 { flex: 1; }
.weight-summary { display: flex; justify-content: space-between; align-items: center; gap: 8px; margin: 1px 0 7px; font-size: 12px; }

View File

@@ -76,6 +76,7 @@ onMounted(() => {
<div class="vert bot">
<div class="button-container">
<button class="btn-primary button-expand sound-click" v-on:click="CreateCampaignWindow" ref="campaignButton">{{ $t("main-menu.create-campaign") }}</button>
<a class="btn-primary button-expand docs-link" href="/docs">{{ $t("main-menu.documentation") }}</a>
</div>
</div>
</div>
@@ -145,6 +146,24 @@ h2, h3 {
flex-direction: column;
}
/* L'enllaç a la documentació és un `<a>` i els botons estan estilats per element, així
que li toca portar el mateix look. */
.docs-link {
display: block;
padding: 14px;
border-radius: 6px;
border: solid 1px var(--color-border);
background-color: var(--color-button-background);
color: var(--color-text);
text-align: center;
text-decoration: none;
transition: 300ms background-color;
}
.docs-link:hover {
background-color: var(--color-button-hover);
}
p {
user-select: none;
}

View File

@@ -1,57 +0,0 @@
<script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import { getBaseUrl } from '~/services/Server';
// A feature of the character sheet, opened from the traits tab (see CharacterSheetWindow.vue).
// The icon, the name and the description come from the Foundry feature item the campaign synced.
const props = defineProps(['data']);
const id = props.data.id;
const feature = props.data.feature ?? {};
const handle = ref(null);
const wrapper = ref(null);
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, { width: 420, height: 500 });
ResetPosition(id, 'center');
});
onBeforeUnmount(() => ClearWindow({ type: 'trait_sheet' }));
const imageUrl = computed(() => {
if (!feature.icon) return '';
return /^(https?:|data:|\/\/)/i.test(feature.icon)
? feature.icon
: `${getBaseUrl()}/public/${feature.icon}`;
});
</script>
<template>
<div class="window-wrapper trait-window" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle" />
<div class="trait-body">
<header class="trait-hero">
<span class="trait-mark" :class="{ empty: !imageUrl }">
<img v-if="imageUrl" :src="imageUrl" alt="">
<span v-else aria-hidden="true">{{ String(feature.name ?? '').slice(0, 1).toUpperCase() }}</span>
</span>
<h1>{{ feature.name }}</h1>
</header>
<p v-if="feature.description" class="trait-description">{{ feature.description }}</p>
</div>
</div>
</template>
<style scoped>
.trait-window { display: flex; align-items: center; flex-direction: column; }
.trait-body { flex: 1; min-height: 0; align-self: stretch; box-sizing: border-box; margin: 10px; padding: 8px; overflow-y: auto; }
.trait-hero { display: flex; align-items: center; gap: 12px; padding-bottom: 10px; margin-bottom: 10px; border-bottom: 1px solid var(--color-border); }
.trait-mark { width: 52px; height: 52px; flex: 0 0 52px; display: grid; place-items: center; overflow: hidden; border: 1px solid var(--color-border); border-radius: 9px; background: var(--color-background-soft); color: var(--color-link); font: 24px MrEavesRemake; }
.trait-mark.empty { border-style: dashed; }
.trait-mark img { width: 100%; height: 100%; object-fit: contain; }
.trait-hero h1 { margin: 0; font: 22px MrEavesRemake; overflow-wrap: anywhere; }
.trait-description { margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; font-size: 13px; line-height: 1.5; opacity: .9; }
</style>

View File

@@ -46,34 +46,6 @@ Headings, **bold**, *italic*, lists, quotes, tables, code and links all work:
Clicking a heading **folds** the section under it — handy when you are reading a long note on a
projector and only want the part you are talking about. Sub-headings fold with their parent.
## Linking to characters, items and other entries
A note can point at the rest of the campaign. While editing, type `[[` and the editor offers the
campaign's notes, characters, items and maps; choose one and it writes a link like `[[Mira]]` (or
`[[Rope of Climbing]]`). The list narrows as you type and the arrow keys, Enter or Tab, and Escape
work the same way as in the widget menu.
In display mode the link shows the entry's name. Resting the pointer on a link to a **character** or
an **item** opens a small preview — the portrait or icon, the class and level, armour class, hit
points and speed for a character; the rarity, weight and description for an item — and clicking it
opens the full sheet in its window. A link to a note opens that note beside the current one, and a
link to a map anchors the map where the notes are.
Links are written by name, so renaming an entry leaves the old link pointing at nothing: it is shown
dimmed and no longer opens anything. Write `[[` again to link the entry under its new name.
### Embedding a character or an item
Put a **!** in front of the link — `![[Mira]]` or `![[Rope of Climbing]]` — and the note shows the
entry itself instead of a link. A character arrives as a small sheet: portrait, class, level and
species, armour class, hit points, speed and ability scores, with the traits, proficiencies and
spells below. An item arrives with its icon, category, rarity, weight, properties and description.
The embedded card is part of the note in display mode, and its **Open** button opens the full sheet,
the same window the sidebar opens. Only characters and items can be embedded; a note or a map written
with the **!** stays as plain text. Name resolution works exactly like a normal link, so an embed of
an entry that has been renamed is shown dimmed.
## Rolling dice in a note
A note can hold a dice widget: a button that rolls and shows the result right there, so the book of a
@@ -85,11 +57,6 @@ Write `@roll` and the expression in square brackets to drop it in the middle of
The goblin attacks with @roll[1d20+4].
```
The editor offers the widgets for you: while editing, typing `@` opens a list of the widgets a note
can use, and choosing one writes its syntax — the inline `@roll[...]` or the block below — with the
cursor where the expression goes. Arrow keys move through the list, Enter or Tab takes the widget,
and Escape closes it.
Or in a block of its own, between `@roll` and `@end`, when the roll is worth showing on its own line:
```markdown
@@ -102,10 +69,6 @@ Either way the widget shows the expression as a button: press it and the dice la
the total spelled out. Press it again to roll again. Only the expression itself goes between `@roll`
and `@end` — write the note about the roll next to the widget, not inside it.
When the note reaches a linked [Foundry world](/docs/foundry), its dice widgets are buttons on the
journal page too: pressing one rolls the expression with Foundry's dice and posts the result to chat,
where the whole table sees it.
The expression understands:
| Written | Meaning |

View File

@@ -49,18 +49,3 @@ the actor it stands for, and **Enter** does the same on a token focused with the
Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a
token off does not remove the character from the campaign.
## Maps from a linked Foundry world
With a Foundry world linked to the campaign, its scenes arrive as maps of their own: each one with the
scene's background picture and the grid laid over it, in the scene's own cell size and where the world
shifts that grid onto the picture. That is all a scene lends a map — what one of your cells stands
for, the folder a map stands in, and whatever you pin or stand on it stay yours, and nothing about a
map goes back to the world.
A scene renamed in Foundry, or its grid moved, updates its map. Take the background picture off a
scene and its map keeps the one it has; delete the scene and its map goes with it the next time the
world sends its whole scene list, which is when the world loads. For the same reason a map you delete
in the campaign comes back on the next world load while its scene is still there — take the scene off
in Foundry to be rid of the map. A map you made yourself is never doubled by the scene of it: a scene
arriving with the name of an unmapped map adopts that one. See [Foundry VTT](/docs/foundry).

View File

@@ -1,8 +1,8 @@
# Foundry VTT
The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's
characters, item directory and scenes arrive in the campaign, and what you change in Dragonroll of
those characters and items goes back to the world.
characters and item directory arrive in the campaign, and what you change in Dragonroll goes back to
the world.
There are two separate parts, and you only need the first of them:
@@ -15,15 +15,9 @@ Character and item sync works without the bridge.
## Installing the module
Foundry VTT v12 to v14. In Foundry's **Setup → Add-on Modules → Install Module**, paste the
manifest URL `https://dragonroll.aranroig.com/foundry/module.json`. Foundry downloads the module
from your Dragonroll server, and the same URL later tells it when an update is available.
A self-hosted Dragonroll serves its own manifest at `https://<your-dragonroll-host>/foundry/module.json`.
Then enable **Dragonroll Foundry API** in the world's module settings. To install by hand instead,
copy the `dragonroll-foundry` folder into `{Foundry user data}/Data/modules/dragonroll-foundry/`
and restart Foundry.
Foundry VTT v12 to v14. Copy the `dragonroll-foundry` folder into
`{Foundry user data}/Data/modules/dragonroll-foundry/`, restart Foundry, and enable **Dragonroll
Foundry API** in the world's module settings.
The module's own settings hold two things you set: the **Dragonroll Endpoint** — the address of your
Dragonroll server, `https://dragonroll.aranroig.com` by default — and **Dragonroll Auto-sync**, which
@@ -57,23 +51,12 @@ Worth knowing:
| The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description |
| The folders grouping that item directory | Item folders with the same names and nesting |
| A folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder |
| The world's **scenes** | The campaign's maps: the scene's background picture and the grid laid over it, in the scene's own cell size |
| A journal per note folder, named after its path — one page per note | Your campaign's notes. They arrive **from** Dragonroll: what you write in a journal does not go back |
The item list is the world's item directory and nothing else. The gear a character carries is that
character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
does not turn up in the campaign's item list. Spells, classes, subclasses, backgrounds, feats and
species are not gear and are not imported.
The world's scenes are the campaign's maps, and only their **background picture** and their **grid**
cross over: a map arrives with the scene's picture and its cell size, and with the grid where the
world shifts it. That is where the two stop — what one of your cells stands for, the folder a map
stands in, the notes pinned onto it and the characters standing on it as tokens stay in the campaign,
and nothing about a map is written back into the world. The scene list goes over when the world links
and when it loads, which is also when the map of a scene the GM deleted goes with it; scenes changed
afterwards arrive as they happen. A scene with no background picture makes no map, and the full list
leaves a map the campaign already had alone, so a grid you lined up yourself survives a reload.
An actor or item keeps the Dragonroll id it was given in a `dragonroll-foundry.actorId` /
`dragonroll-foundry.itemId` flag, and that is what makes the two sides recognise each other. A world
item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of
@@ -84,21 +67,6 @@ few seconds. A **full** snapshot — the one taken when the world links, or forc
directory — is the only thing that prunes: it is the only moment either side can see the whole list and
notice what is gone. Live edits never delete anything.
Notes are the exception that runs one way, because notes are written in Dragonroll: each folder
stands as a journal named after its path. Notes in the root of the campaign share the journal called
**Dragonroll**, while notes in a folder called *Sessions* with a subfolder *Arc 1* share the journal
**Sessions / Arc 1**; every note is a page of the journal of its folder. A note's dice widgets are
buttons there as well: press one in the journal and Foundry rolls it and posts the result to chat, so
advantage and disadvantage roll the way the campaign's notes describe them. The note's `[[links]]`
work in the page too: a link to a note page, a character, an item or a scene opens it in Foundry, and
`![[a character or item]]` is drawn as a sheet preview inside the page. Renaming a folder renames
its journal, and moving a note to another folder moves its page along. The module only pulls the notes
over when something has changed, checking every fifteen seconds, so a note you make, edit or move in
the app appears in its journal within that time, and deleting one takes its page with it. Pages the
campaign does not own — ones the GM made in those journals themselves — are left alone, and nothing
written in a journal travels back to the campaign. A folder journal whose notes have all left is
removed too, unless the GM keeps pages of their own in it.
## Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or

View File

@@ -1,109 +0,0 @@
// The rules behind the note editor's wiki-link autocomplete (type `[[` while editing a note and the
// campaign's notes, actors, items and maps are offered to link to). These helpers hold no state,
// touch no DOM and import nothing, so tests can load them straight from source. Marker.js renders
// `[[target]]` as a link, so the target written here is the entry's label.
// Accent- and case-insensitive, the way the search palette compares names.
function Normalize(text) {
return String(text ?? '')
.normalize('NFD')
.replace(/[\u0300-\u036f]/g, '')
.toLowerCase()
.trim();
}
// The `[[target` the caret is sitting in. `[[The Wr` answers `{ start, query: 'The Wr' }`.
//
// A link is a single line: a `]]` or a newline between the `[[` and the caret closes the token, so
// the menu only follows the link currently being typed. Returns null when there is none.
function FindLinkTrigger(text, caret) {
if (typeof text !== 'string') return null;
const position = Math.max(0, Math.min(Number(caret) || 0, text.length));
const before = text.slice(0, position);
const start = before.lastIndexOf('[[');
if (start === -1) return null;
const query = before.slice(start + 2);
if (query.includes(']]') || query.includes('\n')) return null;
return { start, query };
}
// One `{ id, label, type }` per linkable entry, from the campaign's four lists. Entries without a
// name are left out (they would show as an empty menu row), the rest are sorted by label so the menu
// reads alphabetically whatever order the API answered with.
function BuildLinkSuggestions({ notes, actors, items, maps } = {}) {
const suggestions = [];
const seen = new Set();
const push = (type, list, labelOf) => {
for (const entry of list ?? []) {
const label = String(labelOf(entry) ?? '').trim();
if (!entry?._id || !label) continue;
const key = `${type}:${label}`;
if (seen.has(key)) continue;
seen.add(key);
suggestions.push({ id: String(entry._id), label, type });
}
};
push('note', notes, (note) => note.title);
push('actor', actors, (actor) => actor.name);
push('item', items, (item) => item.name);
push('map', maps, (map) => map.name);
return suggestions.sort((a, b) => a.label.localeCompare(b.label));
}
// The suggestions matching what has been typed. An empty query offers them all; the ones whose label
// starts with it come first, and a match further inside still shows, the way search does it. The list
// is capped so a large campaign cannot open a menu taller than the note.
const MAX_SUGGESTIONS = 50;
function FilterLinkSuggestions(suggestions, query) {
const needle = Normalize(query);
const all = suggestions ?? [];
if (!needle) return all.slice(0, MAX_SUGGESTIONS);
return all
.filter((suggestion) => Normalize(suggestion.label).includes(needle))
.sort((a, b) => {
const startsA = Normalize(a.label).startsWith(needle) ? 0 : 1;
const startsB = Normalize(b.label).startsWith(needle) ? 0 : 1;
return startsA - startsB || a.label.localeCompare(b.label);
})
.slice(0, MAX_SUGGESTIONS);
}
// The entry a written `[[label]]` points at. Links store the label (not the id), so the note looks
// the target up again when it is rendered; the comparison is the same case- and accent-insensitive
// one the menu uses. Returns null when nothing in the campaign carries that label any more.
function FindLinkTarget(suggestions, label) {
const needle = Normalize(label);
if (!needle) return null;
return (suggestions ?? []).find((suggestion) => Normalize(suggestion.label) === needle) ?? null;
}
// Replaces the typed `[[query` with `[[label]]` and returns where the caret goes: just after the
// closing brackets, ready to carry on with the note.
function InsertLinkSuggestion(text, trigger, suggestion) {
const source = String(text ?? '');
const start = trigger?.start ?? 0;
const query = trigger?.query ?? '';
const before = source.slice(0, start);
const after = source.slice(start + 2 + query.length);
const snippet = `[[${suggestion?.label ?? ''}]]`;
return { text: before + snippet + after, caret: start + snippet.length };
}
export {
BuildLinkSuggestions,
FilterLinkSuggestions,
FindLinkTarget,
FindLinkTrigger,
InsertLinkSuggestion
};

View File

@@ -1,71 +0,0 @@
// Fetches the campaign entries a note can link to (`[[…]]`) and keeps them briefly, so the several
// notes a campaign has open share one round of requests. The rules that turn the entries into
// suggestions live in LinkAutocomplete.js; this only talks to the API.
import Server from './Server';
import { BuildLinkSuggestions } from './LinkAutocomplete';
// Long enough to spare the API while a note is being written, short enough that an entry created in
// another note shows up soon after.
const CACHE_TTL = 30 * 1000;
const cache = new Map(); // campaignId → { at, promise }
// The campaign's four lists as the API answers them. The note preview needs the entry itself (a
// character sheet, an item), not only the label the suggestion carries, so the lists are kept as
// they arrive and both readers resolve from the same round of requests.
const LIST_PATHS = {
note: { path: '/note/all', key: 'notes' },
actor: { path: '/actor/list', key: 'actors' },
item: { path: '/item/list', key: 'items' },
map: { path: '/map/list', key: 'maps' }
};
async function fetchList(campaignId, path, key) {
try {
const response = await Server().get(path, { params: { campaign: campaignId } });
if (response.data.status !== 'ok') return [];
return response.data[key] ?? [];
} catch (error) {
return [];
}
}
function LoadCampaignEntries(campaignId) {
const id = campaignId ? String(campaignId) : '';
if (!id) {
return Promise.resolve({ notes: [], actors: [], items: [], maps: [] });
}
const cached = cache.get(id);
if (cached && Date.now() - cached.at < CACHE_TTL) return cached.promise;
const promise = Promise.all(
Object.values(LIST_PATHS).map(({ path, key }) => fetchList(id, path, key))
).then(([notes, actors, items, maps]) => ({ notes, actors, items, maps }));
cache.set(id, { at: Date.now(), promise });
return promise;
}
// The campaign's linkable entries, as BuildLinkSuggestions answers. Without a campaign id there is
// nothing to offer.
function LoadLinkTargets(campaignId) {
return LoadCampaignEntries(campaignId).then((lists) => BuildLinkSuggestions(lists));
}
// The entry a link points at, for the preview the note shows on hover (and to open its sheet). The
// target is one of the suggestions `LoadLinkTargets` answered; the lists it lives in are already
// cached, so this does not make another request.
function LoadLinkEntry(campaignId, type, id) {
const list = LIST_PATHS[type];
if (!list) return Promise.resolve(null);
return LoadCampaignEntries(campaignId).then((lists) => {
return (lists[list.key] ?? []).find((entry) => String(entry._id) === String(id)) ?? null;
});
}
function ClearLinkTargets() {
cache.clear();
}
export { LoadLinkTargets, LoadLinkEntry, ClearLinkTargets };

View File

@@ -0,0 +1,87 @@
// The rules behind the wall segments of a map (the wall editor: drag to draw a segment from grid
// intersection to grid intersection, drag an endpoint to retype it, drag the segment itself to move
// it). Like pins and tokens, walls are stored in image pixels — the very space Foundry draws a
// scene's walls in — so these helpers only translate and snap: they hold no state and talk to no
// API, and the editor saves the whole set the way the viewer ends up with it.
// Screen pixels (relative to the top left corner of the map viewport) → image pixels, clamped to
// the image but never refused: while a wall is being drawn the pointer does leave the image, and
// the endpoint then sticks to its edge instead of vanishing.
function ToDrawPoint(point, view) {
const zoom = Number(view?.zoom);
if (!Number.isFinite(zoom) || zoom <= 0) return null;
const x = (Number(point?.x) - Number(view?.pan?.x ?? 0)) / zoom;
const y = (Number(point?.y) - Number(view?.pan?.y ?? 0)) / zoom;
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
return { x: Math.max(0, x), y: Math.max(0, y) };
}
// The nearest intersection of the grid, in image pixels: a drawn wall's endpoints snap to these,
// so walls line up with the cells whatever offset the map has — the way Foundry snaps its walls
// to the grid too.
function SnapToGrid(point, grid) {
const size = Math.max(1, Number(grid?.gridSize) || 50);
const offsetX = Number(grid?.offsetX) || 0;
const offsetY = Number(grid?.offsetY) || 0;
const x = Number(point?.x);
const y = Number(point?.y);
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
return {
x: Math.max(0, Math.round(offsetX + Math.round((x - offsetX) / size) * size)),
y: Math.max(0, Math.round(offsetY + Math.round((y - offsetY) / size) * size))
};
}
// A wall (image pixels) → screen pixels of the map viewport. Walls are drawn in screen space like
// the pins, so their lines stay one pixel wide whatever the zoom is.
function ToScreenPoint(x, y, view) {
const zoom = Number(view?.zoom) || 0;
return {
x: Number(view?.pan?.x ?? 0) + Number(x ?? 0) * zoom,
y: Number(view?.pan?.y ?? 0) + Number(y ?? 0) * zoom
};
}
function ToScreenWall(wall, view) {
const from = ToScreenPoint(wall?.x1, wall?.y1, view);
const to = ToScreenPoint(wall?.x2, wall?.y2, view);
return { x1: from.x, y1: from.y, x2: to.x, y2: to.y };
}
// A whole wall slid over the map: both endpoints by the same delta, so a moved wall keeps its
// shape and its alignment to the grid it was drawn on. Never off the top left corner.
function MoveWall(wall, dx, dy) {
const x1 = Number(wall?.x1);
const y1 = Number(wall?.y1);
const x2 = Number(wall?.x2);
const y2 = Number(wall?.y2);
const stepX = Number(dx);
const stepY = Number(dy);
if (![x1, y1, x2, y2, stepX, stepY].every(Number.isFinite)) return null;
return {
x1: Math.max(0, Math.round(x1 + stepX)),
y1: Math.max(0, Math.round(y1 + stepY)),
x2: Math.max(0, Math.round(x2 + stepX)),
y2: Math.max(0, Math.round(y2 + stepY))
};
}
// Two endpoints of a segment, snapped or not, long enough to be a wall: a drag that ends where it
// started drew nothing.
function IsWall(wall) {
return Boolean(wall) && Number.isFinite(wall.x1) && Number.isFinite(wall.y1)
&& Number.isFinite(wall.x2) && Number.isFinite(wall.y2)
&& !(wall.x1 === wall.x2 && wall.y1 === wall.y2);
}
export {
IsWall,
MoveWall,
SnapToGrid,
ToDrawPoint,
ToScreenWall
};

View File

@@ -88,32 +88,6 @@ const inlineExtension = {
},
};
// `![[Name]]` embeds the entry itself instead of linking it: the note mounts a card with the
// character's sheet or the item's description where the token was written.
const embedExtension = {
name: "embed",
level: "inline",
start(src) {
return src.indexOf("![[");
},
tokenizer(src) {
const rule = /^!\[\[([^\n]*)\]\]/;
const match = rule.exec(src);
if (!match) return;
return {
type: "embed",
raw: match[0],
link: match[1],
};
},
renderer(token) {
return `<span class="vue-embed" data-href="${escapeAttr(token.link)}"></span>`;
},
};
const linkExtension = {
name: "link_to",
level: "inline",
@@ -134,32 +108,16 @@ const linkExtension = {
},
renderer(token) {
// The link shows the entry's name, not a generic "Link", so a note reads as written. The
// note looks the target up by this label and turns the span into a preview link.
const label = String(token.link ?? "").trim() || token.link;
return `<span class="vue-link" data-href="${escapeAttr(token.link)}" role="link" tabindex="0">${escapeAttr(label)}</span>`;
return `<span class="vue-link" data-href="${escapeAttr(token.link)}">Link</span>`;
},
};
marker.use({
// The embed comes before the link: at the `!` of `![[…]]` the embed tokenizer is offered first,
// so the same label written with the bang does not fall through to the plain link.
extensions: [extension, inlineExtension, embedExtension, linkExtension],
extensions: [extension, inlineExtension, linkExtension],
});
function ParseMarkdown(source) {
return marker.parse(source || "");
}
// The widgets a note can use, as `{ inline: [...names], display: [...names] }`. The note editor's
// `@` autocomplete reads this, so a widget added to `widget_map` is offered there without any other
// change.
const GetWidgetRegistry = () => {
const registry = {};
for (const type of Object.keys(widget_map)) {
registry[type] = Object.keys(widget_map[type]);
}
return registry;
};
export { ParseMarkdown, GetWidget, GetWidgetRegistry };
export { ParseMarkdown, GetWidget };

View File

@@ -1,78 +0,0 @@
// The rules behind the note editor's widget autocomplete (type `@` while editing a note and the
// widgets of Marker.js are offered to insert). These helpers hold no state, touch no DOM and import
// nothing, so tests can load them straight from source.
// What counts as a widget name while the user is typing one, matching the `\w+` Marker.js reads.
const NAME_CHARACTER = /[A-Za-z0-9_]/;
// The `@name` the caret is sitting in. Typing `@ro` answers `{ start, query: 'ro' }`, ready to be
// replaced by the chosen widget.
//
// The `@` has to open a word (start of the note, whitespace or punctuation before it) so an email
// address does not pop the menu open. Returns null when the caret is not in such a token.
function FindWidgetTrigger(text, caret) {
if (typeof text !== 'string') return null;
const position = Math.max(0, Math.min(Number(caret) || 0, text.length));
let start = position;
while (start > 0 && NAME_CHARACTER.test(text[start - 1])) start--;
const at = start - 1;
if (at < 0 || text[at] !== '@') return null;
const before = at > 0 ? text[at - 1] : '';
if (before && NAME_CHARACTER.test(before)) return null;
return { start: at, query: text.slice(start, position) };
}
// The widgets to offer, one entry per way to write each one (`type` is what Marker.js renders:
// `inline` for `@roll[...]`, `display` for the `@roll … @end` block). `registry` is the map of
// widget names per type that GetWidgetRegistry() answers with, so a widget is described once, in
// Marker.js, and shows up here on its own.
function BuildWidgetSuggestions(registry) {
const suggestions = [];
for (const type of ['inline', 'display']) {
for (const name of registry?.[type] ?? []) {
suggestions.push({ name: String(name), type });
}
}
return suggestions;
}
// The suggestions whose name starts with what has been typed. An empty query offers them all.
function FilterWidgetSuggestions(suggestions, query) {
const needle = String(query ?? '').toLowerCase();
const all = suggestions ?? [];
if (!needle) return all.slice();
return all.filter((suggestion) => suggestion.name.toLowerCase().startsWith(needle));
}
// Replaces the typed `@query` with the widget's syntax and says where the caret goes afterwards:
// inside the brackets for an inline widget (`@roll[]`), on the blank line of a block (`@roll\n\n@end`).
function InsertWidgetSuggestion(text, trigger, suggestion) {
const source = String(text ?? '');
const start = trigger?.start ?? 0;
const query = trigger?.query ?? '';
const name = suggestion?.name ?? '';
const before = source.slice(0, start);
const after = source.slice(start + 1 + query.length);
const snippet = suggestion?.type === 'display'
? `@${name}\n\n@end`
: `@${name}[]`;
return {
text: before + snippet + after,
// 1 for the `@` and 1 for either the opening bracket or the blank line.
caret: start + name.length + 2
};
}
export {
BuildWidgetSuggestions,
FilterWidgetSuggestions,
FindWidgetTrigger,
InsertWidgetSuggestion
};

View File

@@ -82,12 +82,6 @@ const defWindows = {
close: () => ClearWindow({type: 'character_sheet'}),
movable: true
},
trait_sheet: {
title: 'windows.trait-sheet',
component: () => import('~/components/windows/TraitWindow.vue'),
close: () => ClearWindow({ type: 'trait_sheet' }),
movable: true
},
item_sheet: {
title: 'windows.item-sheet',
component: () => import('~/components/windows/ItemSheetWindow.vue'),

View File

@@ -13,6 +13,7 @@
"saved": "S'ha desat la configuració de la campanya.",
"saving": "Desant...",
"services": {
"help": "Tots els serveis es connecten igual: demanen a Dragonroll un enllaç de registre, te'l mostren i tries aquesta campanya allà. Des d'aquí no es connecta res.",
"not-connected": "No connectat",
"unlink": "Desenllaça",
"unlinked": "{service} ja no està connectat amb aquesta campanya.",
@@ -110,14 +111,17 @@
"drop-hint": "Deixa anar per posar l'actor en aquest mapa",
"open": "Obre la fitxa de personatge", "remove": "Treu la fitxa",
"error": "No s'han pogut canviar les fitxes d'aquest mapa."
}
},
"link-preview": {
"open-character": "Obre la fitxa de personatge",
"open-item": "Obre la fitxa de l'objecte",
"no-description": "No hi ha cap descripció afegida.",
"not-found": "Aquesta entrada ja no és a la campanya.",
"close": "Tanca la vista prèvia"
"walls": {
"edit": "Edita murs",
"hint": "Arrossega sobre el mapa per dibuixar un mur · arrossega'n els extrems per canviar-lo, el cos per moure'l",
"wall": "Mur",
"sight-block": "Bloqueja la vista", "sight-open": "Permet la vista",
"move-block": "Bloqueja el moviment", "move-open": "Permet el moviment",
"door": "Porta", "door-none": "No és porta", "door-closed": "Porta tancada", "door-open": "Porta oberta",
"remove": "Treu el mur",
"error": "No s'han pogut guardar els murs d'aquest mapa."
}
},
"character-sheet": {
"title": "Fitxa de personatge", "name": "Nom del personatge", "class": "Classe", "subclass": "Subclasse", "unset-class": "Classe sense definir",

View File

@@ -4,6 +4,7 @@
"world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.",
"actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.",
"item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry.",
"scene-already-synced": "Un altre mapa d'aquesta campanya ja està sincronitzat amb aquella escena del Foundry.",
"icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.",
"icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.",
"import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.",

View File

@@ -3,9 +3,5 @@
"notes": {
"saved": "Nota desada",
"save-error": "No s'ha pogut desar la nota"
},
"widgets": {
"inline": "en una frase",
"display": "a la seva pròpia línia"
}
}

View File

@@ -12,7 +12,6 @@
"pinned-note": "Nota fixada",
"documentation": "Documentació",
"item-sheet": "Objecte",
"trait-sheet": "Tret",
"icon-source": "Tria una icona",
"foundry-icons": "Icones del Foundry"
}

View File

@@ -17,6 +17,7 @@
"saved": "Campaign settings saved.",
"saving": "Saving...",
"services": {
"help": "Every service connects the same way: it asks Dragonroll for a sign-up link, shows it to you, and you pick this campaign there. Nothing connects from here.",
"not-connected": "Not connected",
"unlink": "Unlink",
"unlinked": "{service} is no longer connected to this campaign.",
@@ -114,14 +115,17 @@
"drop-hint": "Drop to place the actor on this map",
"open": "Open character sheet", "remove": "Remove token",
"error": "Unable to change the tokens of this map."
}
},
"link-preview": {
"open-character": "Open character sheet",
"open-item": "Open item sheet",
"no-description": "No description added.",
"not-found": "This entry is no longer in the campaign.",
"close": "Close preview"
"walls": {
"edit": "Edit walls",
"hint": "Drag on the map to draw a wall · drag its ends to retype it, its body to move it",
"wall": "Wall",
"sight-block": "Block sight", "sight-open": "Let sight through",
"move-block": "Block movement", "move-open": "Let movement through",
"door": "Door", "door-none": "Not a door", "door-closed": "Closed door", "door-open": "Open door",
"remove": "Remove wall",
"error": "Unable to save the walls of this map."
}
},
"character-sheet": {
"title": "Character Sheet", "name": "Character name", "class": "Class", "subclass": "Subclass", "unset-class": "Class not set",

View File

@@ -4,6 +4,7 @@
"world-already-linked": "This Foundry world is already linked to another campaign.",
"actor-already-synced": "Another actor in this campaign is already synced with that Foundry actor.",
"item-already-synced": "Another item in this campaign is already synced with that Foundry item.",
"scene-already-synced": "Another map in this campaign is already synced with that Foundry scene.",
"icons-unavailable": "Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.",
"icons-no-world-url": "This campaign has no Foundry world address. Set it under campaign settings, in the Integrations tab.",
"import-not-linked": "This campaign has no Foundry world linked to it. Connect one under campaign settings, in the Integrations tab.",

View File

@@ -10,9 +10,5 @@
"notes": {
"saved": "Note saved",
"save-error": "Unable to save the note"
},
"widgets": {
"inline": "in a sentence",
"display": "on its own line"
}
}

View File

@@ -12,7 +12,6 @@
"pinned-note": "Pinned note",
"documentation": "Documentation",
"item-sheet": "Item",
"trait-sheet": "Trait",
"icon-source": "Choose an icon",
"foundry-icons": "Foundry icons"
}

View File

@@ -13,6 +13,7 @@
"saved": "Se han guardado los ajustes de la campaña.",
"saving": "Guardando...",
"services": {
"help": "Todos los servicios se conectan igual: piden a Dragonroll un enlace de registro, te lo muestran y eliges esta campaña allí. Desde aquí no se conecta nada.",
"not-connected": "Sin conectar",
"unlink": "Desvincular",
"unlinked": "{service} ya no está conectado a esta campaña.",
@@ -110,14 +111,17 @@
"drop-hint": "Suelta para colocar al actor en este mapa",
"open": "Abrir hoja de personaje", "remove": "Quitar la ficha",
"error": "No se pudieron cambiar las fichas de este mapa."
}
},
"link-preview": {
"open-character": "Abrir hoja de personaje",
"open-item": "Abrir hoja de objeto",
"no-description": "No hay descripción añadida.",
"not-found": "Esta entrada ya no está en la campaña.",
"close": "Cerrar la vista previa"
"walls": {
"edit": "Editar muros",
"hint": "Arrastra sobre el mapa para dibujar un muro · arrastra sus extremos para cambiarlo, su cuerpo para moverlo",
"wall": "Muro",
"sight-block": "Bloquear la visión", "sight-open": "Permitir la visión",
"move-block": "Bloquear el movimiento", "move-open": "Permitir el movimiento",
"door": "Puerta", "door-none": "No es puerta", "door-closed": "Puerta cerrada", "door-open": "Puerta abierta",
"remove": "Quitar muro",
"error": "No se pudieron guardar los muros de este mapa."
}
},
"character-sheet": {
"title": "Hoja de personaje", "name": "Nombre del personaje", "class": "Clase", "subclass": "Subclase", "unset-class": "Clase sin definir",

View File

@@ -4,6 +4,7 @@
"world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.",
"actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.",
"item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry.",
"scene-already-synced": "Otro mapa de esta campaña ya está sincronizado con esa escena de Foundry.",
"icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.",
"icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.",
"import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.",

View File

@@ -3,9 +3,5 @@
"notes": {
"saved": "Nota guardada",
"save-error": "No se ha podido guardar la nota"
},
"widgets": {
"inline": "en una frase",
"display": "en su propia línea"
}
}

View File

@@ -12,7 +12,6 @@
"pinned-note": "Nota fijada",
"documentation": "Documentación",
"item-sheet": "Objeto",
"trait-sheet": "Rasgo",
"icon-source": "Elegir icono",
"foundry-icons": "Iconos de Foundry"
}

View File

@@ -1,7 +0,0 @@
import { defineEventHandler, setHeader } from 'h3'
import { buildFoundryModuleZip } from '../../utils/foundry-module.js'
export default defineEventHandler((event) => {
setHeader(event, 'content-type', 'application/zip')
return buildFoundryModuleZip()
})

View File

@@ -1,14 +0,0 @@
import { defineEventHandler, getRequestURL } from 'h3'
import { readModuleManifest } from '../../utils/foundry-module.js'
// Foundry's manifest URL: the module.json plus the two absolute URLs it needs to install and to
// check for updates later. Built from the request so every self-hosted Dragonroll serves its own.
export default defineEventHandler((event) => {
const origin = getRequestURL(event).origin
return {
...readModuleManifest(),
manifest: `${origin}/foundry/module.json`,
download: `${origin}/foundry/dragonroll-foundry.zip`,
}
})

View File

@@ -1,110 +0,0 @@
// Serves the Foundry module as a real installable package: Foundry fetches a manifest (module.json)
// and then a zip of the module. The zip is built from `dragonroll-foundry/` at request time, so it
// can never drift from the source folder. Stored (uncompressed) entries keep the writer small and
// dependency-free; the module is a few dozen KB.
import { existsSync, readFileSync, readdirSync } from 'node:fs'
import { join, relative, resolve, sep } from 'node:path'
const MODULE_DIR = 'dragonroll-foundry'
function resolveModuleDir() {
const candidates = [
resolve(process.cwd(), MODULE_DIR), // production image: /app/dragonroll-foundry
resolve(process.cwd(), '..', MODULE_DIR), // dev server: frontend/ -> repository root
]
const dir = candidates.find((candidate) => existsSync(join(candidate, 'module.json')))
if (!dir) throw new Error(`Cannot find ${MODULE_DIR}/module.json`)
return dir
}
function listFiles(dir, base = dir) {
return readdirSync(dir, { withFileTypes: true })
.flatMap((entry) => {
const full = join(dir, entry.name)
return entry.isDirectory()
? listFiles(full, base)
: [relative(base, full).split(sep).join('/')]
})
.sort()
}
const CRC_TABLE = new Uint32Array(256).map((_, index) => {
let value = index
for (let bit = 0; bit < 8; bit++) {
value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1
}
return value >>> 0
})
function crc32(data) {
let crc = 0xffffffff
for (const byte of data) crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8)
return (crc ^ 0xffffffff) >>> 0
}
export function readModuleManifest() {
return JSON.parse(readFileSync(join(resolveModuleDir(), 'module.json'), 'utf8'))
}
export function buildFoundryModuleZip() {
const dir = resolveModuleDir()
const files = listFiles(dir)
const localParts = []
const centralParts = []
let offset = 0
for (const name of files) {
const data = readFileSync(join(dir, name))
const nameBuffer = Buffer.from(name, 'utf8')
const crc = crc32(data)
const header = Buffer.alloc(30)
header.writeUInt32LE(0x04034b50, 0) // local file header
header.writeUInt16LE(20, 4) // version needed
header.writeUInt16LE(0x0800, 6) // UTF-8 names
header.writeUInt16LE(0, 8) // stored
header.writeUInt16LE(0, 10) // time
header.writeUInt16LE(0x21, 12) // 1980-01-01, fixed so the zip is reproducible
header.writeUInt32LE(crc, 14)
header.writeUInt32LE(data.length, 18)
header.writeUInt32LE(data.length, 22)
header.writeUInt16LE(nameBuffer.length, 26)
header.writeUInt16LE(0, 28)
localParts.push(header, nameBuffer, data)
const entry = Buffer.alloc(46)
entry.writeUInt32LE(0x02014b50, 0) // central directory header
entry.writeUInt16LE(0x031e, 4) // made by UNIX, version 3.0
entry.writeUInt16LE(20, 6) // version needed
entry.writeUInt16LE(0x0800, 8)
entry.writeUInt16LE(0, 10)
entry.writeUInt16LE(0, 12)
entry.writeUInt16LE(0x21, 14)
entry.writeUInt32LE(crc, 16)
entry.writeUInt32LE(data.length, 20)
entry.writeUInt32LE(data.length, 24)
entry.writeUInt16LE(nameBuffer.length, 28)
entry.writeUInt16LE(0, 30) // extra length
entry.writeUInt16LE(0, 32) // comment length
entry.writeUInt16LE(0, 34) // disk
entry.writeUInt16LE(0, 36) // internal attributes
entry.writeUInt32LE((0o100644 << 16) >>> 0, 38) // -rw-r--r--
entry.writeUInt32LE(offset, 42)
centralParts.push(entry, nameBuffer)
offset += header.length + nameBuffer.length + data.length
}
const central = Buffer.concat(centralParts)
const end = Buffer.alloc(22)
end.writeUInt32LE(0x06054b50, 0) // end of central directory
end.writeUInt16LE(0, 4) // disk
end.writeUInt16LE(0, 6) // disk with the central directory
end.writeUInt16LE(files.length, 8)
end.writeUInt16LE(files.length, 10)
end.writeUInt32LE(central.length, 12)
end.writeUInt32LE(offset, 16)
end.writeUInt16LE(0, 20) // comment length
return Buffer.concat([...localParts, central, end])
}

View File

@@ -368,7 +368,7 @@ test("a carried item brings its own icon", () => {
// --- The traits tab syncs --------------------------------------------------------
test("the world's own traits and features reach the campaign", () => {
test("the world's own traits reach the campaign", () => {
const fromText = foundryActorToCharacter({ name: "Thalia", system: { details: { trait: "Spellcaster.<br>Light sleeper." } } });
assert.equal(fromText.traits, "Spellcaster.\nLight sleeper.");
@@ -376,17 +376,12 @@ test("the world's own traits and features reach the campaign", () => {
name: "Thalia",
system: {},
items: [
{ name: "Darkvision", type: "feat", img: "http://vtt.test/icons/eye.svg", system: { type: { value: "race" }, description: { value: "<p>See in the dark.</p>" } } },
{ name: "Second Wind", type: "feat", system: { type: { value: "class" }, description: { value: "Regain hit points." } } },
{ name: "Alert", type: "feat", system: { type: { value: "feat" }, description: { value: "Never surprised." } } },
{ name: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } },
{ name: "Brave", type: "feat", system: { featType: ["tr"], description: { value: "Advantage on saves." } } },
{ name: "Alert", type: "feat", system: { featType: "feat", description: { value: "Never surprised." } } },
],
});
assert.deepEqual(fromFeatures.features, [
{ name: "Darkvision", description: "See in the dark.", icon: "http://vtt.test/icons/eye.svg" },
{ name: "Second Wind", description: "Regain hit points.", icon: "" },
{ name: "Alert", description: "Never surprised.", icon: "" },
], "each feature is a row of its own, with the world's icon and text");
assert.ok(!("traits" in fromFeatures), "the feature items are not repeated as free text");
assert.equal(fromFeatures.traits, "Darkvision\nSee in the dark.\n\nBrave\nAdvantage on saves.");
});
test("the world leads the traits tab, and what the campaign wrote fills in when it has none", () => {
@@ -415,50 +410,6 @@ test("an actor that holds no traits does not clear what the campaign has", () =>
assert.ok(!("traits" in character), "a live edit that knows nothing about traits leaves the tab as it is");
});
test("features stand like inventory rows and open their description", () => {
const panel = /<section class="sheet-panel traits-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(panel, /v-for="\(trait, index\) in form\.features"/, "one row per feature");
assert.match(panel, /resolveImage\(trait\.icon\)/, "the world's icon sits on the left");
assert.match(panel, /@click="openTrait\(trait\)"/, "clicking a row opens its description");
assert.match(read("frontend", "app", "services", "WindowDefinitions.js"), /trait_sheet: \{/);
assert.deepEqual(
normalizeActor({ features: [{ name: "Darkvision", description: "See in the dark.", icon: "eye.svg" }] }).features,
[{ name: "Darkvision", description: "See in the dark.", icon: "eye.svg" }]
);
assert.deepEqual(normalizeActor({}).features, []);
});
// A forced actor sync from the module's context menu replaces everything the campaign
// holds for that actor (Syndria98/dragonroll#96): the fields a live edit leaves out when
// the world says nothing are written empty instead of kept, and the campaign's own text
// on the actor's flag does not survive it.
test("a forced sync writes empty the fields a live edit would leave out", () => {
const actor = {
name: "Thalia",
system: {},
items: [],
flags: { [MODULE_ID]: { traits: "What the campaign typed", proficiencies: "Armour, tools" } },
};
const live = foundryActorToCharacter(actor);
assert.equal(live.traits, "What the campaign typed", "a live edit fills the traits tab from the actor's flag");
assert.equal(live.proficiencies, "Armour, tools", "and the free-text proficiencies from it too");
assert.ok(
!("tools" in live) && !("languages" in live) && !("skills" in live) && !("savingThrows" in live) && !("currency" in live),
"and says nothing about the toggles and lists the world has no data for"
);
const replaced = foundryActorToCharacter(actor, true);
assert.equal(replaced.traits, "", "a forced sync clears the traits the campaign typed");
assert.equal(replaced.proficiencies, "", "down to the free-text proficiencies");
assert.deepEqual(replaced.tools, []);
assert.deepEqual(replaced.languages, []);
assert.deepEqual(replaced.skills, {});
assert.deepEqual(replaced.savingThrows, {});
assert.deepEqual(replaced.currency, {});
});
// --- The module sends the names a sheet outside Foundry can read -----------------
function makeWorld({ actor, config = {}, worldItems = [] }) {

View File

@@ -51,9 +51,7 @@ test("traits and species stand in their own fields, not among the carried items"
"the inventory holds what the character carries, and nothing else");
assert.deepEqual(character.inventory[0],
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" });
assert.deepEqual(character.features,
[{ name: "Darkvision", description: "See in the dark.", icon: "" }],
"the feat stands as a feature row, where the sheet shows it");
assert.equal(character.traits, "Darkvision\nSee in the dark.", "the feat is read as a trait, where the sheet shows it");
assert.equal(character.spells, "Magic Missile", "and the spell where its tab shows it");
});
@@ -135,8 +133,6 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
@@ -147,8 +143,6 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -271,8 +271,6 @@ function loadFoundryWriters({ seed = {} } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
@@ -283,8 +281,6 @@ function loadFoundryWriters({ seed = {} } = {}) {
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
@@ -332,46 +328,6 @@ test("an actor the world has never been seen as becomes one row, and the next im
assert.equal(sync.models["../models/Actor"].rows[0].foundryActorId, "actor-9");
});
// A forced sync from the module's context menu (Syndria98/dragonroll#96) replaces
// everything the campaign holds for the actor; a live change is a merge and leaves the
// fields the world says nothing about to the campaign.
test("a forced actor sync clears what the campaign wrote; a live change keeps it", async () => {
const sync = loadFoundryWriters({
seed: { actors: [{
_id: "actor-1",
name: "Thalia",
foundryActorId: "actor-1",
traits: "A trait the campaign wrote",
tools: ["Thieves' tools"],
languages: ["Elvish"],
skills: { perception: true },
savingThrows: { dex: true },
currency: { gp: 50 },
}] },
});
// The world says nothing about any of those: the fields a live edit leaves out.
const worldActor = { _id: "actor-1", name: "Thalia", type: "character", system: {} };
await sync.writers.saveFoundryActor(sync.campaign, worldActor, false, false);
let row = sync.models["../models/Actor"].rows[0];
assert.equal(row.traits, "A trait the campaign wrote", "a live push leaves what the campaign wrote alone");
assert.deepEqual(row.tools, ["Thieves' tools"]);
assert.deepEqual(row.languages, ["Elvish"]);
assert.deepEqual(row.skills, { perception: true });
assert.deepEqual(row.savingThrows, { dex: true });
assert.deepEqual(row.currency, { gp: 50 });
await sync.writers.saveFoundryActor(sync.campaign, worldActor, false, true);
row = sync.models["../models/Actor"].rows[0];
assert.equal(row.name, "Thalia", "the actor is still the one the world sent");
assert.equal(row.traits, "", "a forced sync clears the trait the campaign wrote");
assert.deepEqual(row.tools, [], "and the tools, languages, skills, saving throws and coin it held");
assert.deepEqual(row.languages, []);
assert.deepEqual(row.skills, {});
assert.deepEqual(row.savingThrows, {});
assert.deepEqual(row.currency, {});
});
test("a hand-made item folds into the import instead of doubling, and keeps being updated", async () => {
const sync = loadFoundryWriters({
seed: { items: [{ _id: "item-1", name: "Longsword", quantity: 1 }] },

View File

@@ -1,87 +0,0 @@
// Tests for the Foundry manifest the frontend serves (Syndria98/dragonroll#111): Foundry installs a
// module from a manifest URL and then downloads a zip, so the zip has to hold `module.json` and every
// module file at its root, and the manifest has to be the source module.json with absolute URLs.
//
// `frontend/server/utils/foundry-module.js` builds both. It is loaded straight from source, with its
// `node:` imports, the way the other tests load frontend code; the routes on top of it only add the
// request origin.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const { pathToFileURL } = require("node:url");
const moduleDir = path.join(__dirname, "..", "dragonroll-foundry");
const moduleUtil = pathToFileURL(
path.join(__dirname, "..", "frontend", "server", "utils", "foundry-module.js"),
).href;
function readSourceFiles(dir, base = dir) {
return fs.readdirSync(dir, { withFileTypes: true })
.flatMap((entry) => {
const full = path.join(dir, entry.name);
return entry.isDirectory()
? readSourceFiles(full, base)
: [path.relative(base, full).split(path.sep).join("/")];
})
.sort();
}
// Reads a stored (uncompressed) zip through its central directory, checking each local header.
function readZipEntries(zip) {
const eocd = zip.lastIndexOf(Buffer.from([0x50, 0x4b, 0x05, 0x06]));
assert.ok(eocd >= 0, "the zip has an end of central directory record");
const count = zip.readUInt16LE(eocd + 10);
let offset = zip.readUInt32LE(eocd + 16);
const entries = [];
for (let index = 0; index < count; index++) {
assert.equal(zip.readUInt32LE(offset), 0x02014b50, "central directory header");
assert.equal(zip.readUInt16LE(offset + 10), 0, "stored, not deflated");
const nameLength = zip.readUInt16LE(offset + 28);
const extraLength = zip.readUInt16LE(offset + 30);
const commentLength = zip.readUInt16LE(offset + 32);
const localOffset = zip.readUInt32LE(offset + 42);
const name = zip.toString("utf8", offset + 46, offset + 46 + nameLength);
assert.equal(zip.readUInt32LE(localOffset), 0x04034b50, "local file header");
const dataStart = localOffset + 30
+ zip.readUInt16LE(localOffset + 26)
+ zip.readUInt16LE(localOffset + 28);
const size = zip.readUInt32LE(localOffset + 18);
entries.push({ name, data: zip.subarray(dataStart, dataStart + size) });
offset += 46 + nameLength + extraLength + commentLength;
}
return entries;
}
test("the manifest is the module's module.json", async () => {
const { readModuleManifest } = await import(moduleUtil);
const manifest = readModuleManifest();
const source = JSON.parse(fs.readFileSync(path.join(moduleDir, "module.json"), "utf8"));
assert.deepEqual(manifest, source);
assert.equal(manifest.id, "dragonroll-foundry");
assert.ok(manifest.version);
});
test("the zip installs every module file at its root, byte for byte", async () => {
const { buildFoundryModuleZip } = await import(moduleUtil);
const entries = readZipEntries(buildFoundryModuleZip());
assert.deepEqual(entries.map((entry) => entry.name), readSourceFiles(moduleDir));
assert.ok(entries.some((entry) => entry.name === "module.json"));
assert.ok(entries.some((entry) => entry.name === "scripts/api.js"));
assert.ok(entries.some((entry) => entry.name === "styles/dragonroll.css"));
for (const entry of entries) {
assert.deepEqual(entry.data, fs.readFileSync(path.join(moduleDir, entry.name)), entry.name);
}
});

View File

@@ -1,938 +0,0 @@
// Tests for the campaign's notes reaching the Foundry world as journal pages
// (Syndria98/dragonroll#98): each Dragonroll folder stands as a journal named after
// its path (root notes share "Dragonroll"), written by the module and kept in step
// with the campaign. The copy runs one way — notes are written in Dragonroll — so
// the backend answers with the notes and their folder paths and remembers each
// note's page; the module reads them, renders the markdown, moves a page when its
// note changes folder, and prunes the page of a note the campaign deleted.
//
// Both sides are loaded the way the other Foundry tests do it: the sync route runs
// against a stubbed `require` (models answer with plain objects and a small filter
// matcher), and the Foundry module is loaded into a `node:vm` context holding
// stubbed Foundry globals (`game.journal` and `JournalEntry` included) with fake
// timers, like tests/item-folder-sync.test.js.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const MODULE_ID = "dragonroll-foundry";
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
// --- The sync route against stubbed models -------------------------------------
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and
// lets `select()`, `sort()` and `limit()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
limit: (count) => mongooseQuery(value.slice(0, count)),
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Enough of the query language the note routes use: equality, $or, $in, $nin,
// $exists, $ne. Anything else is a filter this test did not expect and says so.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
if (key === "$or") return expected.some((part) => matches(document, part));
const value = document?.[key];
if (expected && typeof expected === "object" && !Array.isArray(expected)) {
return Object.entries(expected).every(([operator, wanted]) => {
if (operator === "$exists") return (value !== undefined && value !== null) === wanted;
if (operator === "$in") return wanted.some((entry) => String(value) === String(entry));
if (operator === "$nin") return !wanted.some((entry) => String(value) === String(entry));
if (operator === "$ne") return String(value ?? "") !== String(wanted ?? "");
throw new Error(`filter operator "${key}.${operator}" is not stubbed`);
});
}
return String(value ?? "") === String(expected ?? "");
});
}
function fakeModel(table, seed = [], campaignId) {
const rows = [];
let counter = 0;
function Document(data = {}) {
counter += 1;
this._id = `${table}-${counter}`;
this.isNew = true;
this.foundryNames = [];
Object.assign(this, data);
}
Document.prototype.save = async function save() {
if (this.isNew) rows.push(this);
this.isNew = false;
return this;
};
Object.defineProperty(Document.prototype, "id", { get() { return this._id; } });
for (const data of seed) {
// A seeded row belongs to the campaign the requests are made against unless the
// seed says otherwise: the routes scope every lookup by campaign.
const row = new Document({ campaign: campaignId, ...data });
row.isNew = false;
rows.push(row);
}
const model = function Model(data) { return new Document(data); };
model.rows = rows;
model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null;
model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter)));
model.deleteOne = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.deleteMany = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.updateMany = async (filter, update) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) Object.assign(row, update.$set ?? {});
return { modifiedCount: hit.length };
};
return model;
}
// The Foundry sync route with every model it requires stubbed. `seed` pre-fills the
// tables with documents the campaign already holds.
function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId };
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, body = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; }, set: () => {} };
const req = { body, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token" : "") };
await handlers[handlers.length - 1](req, res);
return res.payload;
}
return { call, models, campaign };
}
// --- The sync route: the notes it answers and the page ids it keeps ---------------
test("the notes revision folds the campaign's notes into one hash", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "hi" },
{ _id: "note-2", title: "Tavern Brawl", content: "ho" },
],
},
});
const first = await sync.call("GET /sync/notes/revision");
assert.equal(first.status, "ok");
assert.match(first.revision, /^[0-9a-f]{64}$/, "a sha-256 of the notes, not their content");
sync.models["../models/Note"].rows[0].content = "hi there";
const edited = await sync.call("GET /sync/notes/revision");
assert.notEqual(edited.revision, first.revision, "editing a note moves the revision");
sync.models["../models/Note"].rows[0].content = "hi";
sync.models["../models/Note"].rows[0].foundryPageId = "page-9";
const mapped = await sync.call("GET /sync/notes/revision");
assert.equal(mapped.revision, first.revision, "mapping a note to its page is not an edit");
});
test("the world reads the campaign's notes with their content and page mapping", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "- rope" },
],
},
});
const response = await sync.call("GET /sync/notes");
assert.equal(response.status, "ok");
assert.deepEqual(response.notes.map((note) => note.title), ["Session 1", "Tavern Brawl"]);
assert.equal(response.notes[0].content, "**The start**", "the markdown source travels: the module renders it");
assert.equal(response.notes[0].foundryPageId, "page-9", "and the note says which page it already stands as");
});
test("the world reads each note with the path of the folder it lives in", async () => {
const sync = loadSyncRoute({
seed: {
folders: [
{ _id: "folder-1", name: "Sessions", parentFolder: null },
{ _id: "folder-2", name: "Arc 1", parentFolder: "folder-1" },
],
notes: [
{ _id: "note-1", title: "Root", content: "root" },
{ _id: "note-2", title: "In folder", content: "folder", folder: "folder-1" },
{ _id: "note-3", title: "Deep", content: "deep", folder: "folder-2" },
],
},
});
const response = await sync.call("GET /sync/notes");
const pathByTitle = Object.fromEntries(response.notes.map((note) => [note.title, note.folderPath]));
assert.deepEqual(pathByTitle, {
Root: "",
"In folder": "Sessions",
Deep: "Sessions / Arc 1",
}, "the module names the journal of a note after its whole folder path");
});
test("renaming a folder moves the notes revision", async () => {
const sync = loadSyncRoute({
seed: {
folders: [{ _id: "folder-1", name: "Sessions", parentFolder: null }],
notes: [{ _id: "note-1", title: "Session 1", content: "hi", folder: "folder-1" }],
},
});
const before = await sync.call("GET /sync/notes/revision");
sync.models["../models/Folder"].rows[0].name = "Chapters";
const after = await sync.call("GET /sync/notes/revision");
assert.notEqual(after.revision, before.revision,
"a folder rename has to reach the world as another journal name");
});
test("mapping a note to the page the module made keeps them paired", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(response.status, "ok");
assert.equal(sync.models["../models/Note"].rows[0].foundryPageId, "page-9");
// Mapping the same pair again is the module checking, not a conflict.
const again = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(again.status, "ok");
});
test("a page already mapped to another note is refused", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "hi", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "ho" },
],
},
});
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-2", foundryPageId: "page-9",
});
assert.equal(response.status, "error");
assert.equal(response.msg, "foundry.errors.note-already-synced");
assert.equal(sync.models["../models/Note"].rows.find((row) => row._id === "note-2").foundryPageId, undefined,
"the first note keeps its page");
});
test("map-note wants this world's note and a page for it", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
assert.equal((await sync.call("POST /sync/map-note", { worldId: "world-1" })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/map-note", { noteId: "note-1", foundryPageId: "page-9" })).msg, "errors.missing-data",
"another world cannot map this campaign's note");
const gone = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-gone", foundryPageId: "page-9",
});
assert.equal(gone.msg, "errors.notfound");
});
// --- The Foundry module writes the journal ---------------------------------------
// Foundry's `update` takes dotted paths ("flags.dragonroll-foundry.noteId"); an
// embedded document's own id is not a path to set.
function writeFoundryPaths(target, data) {
for (const [key, value] of Object.entries(data)) {
if (key === "_id") continue;
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
return target;
}
function makeWorld() {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
intervals: new Map(),
// What Dragonroll answers the notes reconcile with. Mapping a page answers
// like the real backend: the note keeps the page id, so later reads carry it.
remoteNotes: [],
rollMessages: [],
clickListeners: [],
nextId: 1,
};
const journals = [];
const makePage = (journal, data = {}) => {
const page = {
id: `page-${state.nextId++}`,
documentName: "JournalEntryPage",
name: data.name,
text: { content: data.text?.content ?? "" },
flags: data.flags ?? {},
writes: 0,
get uuid() { return `JournalEntry.${journal.id}.JournalEntryPage.${this.id}`; },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(update) {
page.writes += 1;
writeFoundryPaths(page, update);
return page;
},
async delete() {
const index = journal.pages.contents.indexOf(page);
if (index >= 0) journal.pages.contents.splice(index, 1);
},
};
return page;
};
const makeJournal = (data = {}) => {
const pages = [];
return {
id: `journal-${state.nextId++}`,
name: data.name,
documentName: "JournalEntry",
flags: data.flags ?? {},
get uuid() { return `JournalEntry.${this.id}`; },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) },
async update(update) { return writeFoundryPaths(this, update); },
async delete() {
const index = journals.indexOf(this);
if (index >= 0) journals.splice(index, 1);
},
async createEmbeddedDocuments(documentName, docs) {
assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages");
// Foundry's own page validation refuses a page without a name.
for (const doc of docs) assert.ok(doc.name, "a journal page needs a non-empty name");
const created = docs.map((doc) => makePage(this, doc));
pages.push(...created);
return created;
},
};
};
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
document: {
addEventListener(name, fn) {
if (name === "click") state.clickListeners.push(fn);
},
},
Roll: class FakeRoll {
constructor(formula) {
this.formula = formula;
this.evaluated = false;
}
async evaluate() {
this.evaluated = true;
return this;
}
async toMessage(data) {
assert.equal(this.evaluated, true, "the roll is evaluated before it reaches chat");
state.rollMessages.push({ formula: this.formula, ...data });
}
},
ChatMessage: { getSpeaker: () => ({ alias: "GM" }) },
ui: { notifications: { info() {}, warn() {}, error() {} } },
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); },
},
setTimeout: (fn, delay = 0) => {
const id = state.nextId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: (fn, delay = 0) => {
// Recorded, never run by itself: tests ask for a periodic reconcile with
// `runIntervals`, so the ones watching single pushes stay on their own.
const id = state.nextId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
fetch: async (url, options = {}) => {
const href = String(url);
const body = options.body ? JSON.parse(options.body) : null;
state.requests.push({ href, method: options.method, body });
if (href.includes("foundry/sync/map-note")) {
const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId));
if (note) note.foundryPageId = body.foundryPageId;
return { ok: true, status: 200, json: async () => ({ status: "ok", note }) };
}
// The cheap change check: a hash of the notes' content, so changing
// `remoteNotes` (and nothing else) is what makes the module pull them over,
// like the backend hashing the campaign's notes does.
if (href.includes("foundry/sync/notes/revision")) {
const revision = state.remoteNotes
.map((note) => [
note._id, note.title ?? "", note.content ?? "",
note.folder ?? "", note.folderPath ?? "",
].join("\u0000"))
.sort()
.join("\u0001");
return { ok: true, status: 200, json: async () => ({ status: "ok", revision }) };
}
if (href.includes("foundry/sync/notes")) {
return { ok: true, status: 200, json: async () => ({ status: "ok", notes: state.remoteNotes }) };
}
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
JournalEntry: {
async create(data) {
const journal = makeJournal(data);
journals.push(journal);
return [journal];
},
},
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: [], get: () => null },
items: { contents: [], get: () => null },
folders: { contents: [], get: () => null },
journal: { contents: journals, get: (id) => journals.find((journal) => journal.id === id) },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.journals = () => journals;
state.addJournal = (name, flags = {}) => {
const journal = makeJournal({ name, flags });
journals.push(journal);
return journal;
};
state.addPage = (journal, data) => {
const page = makePage(journal, data);
journal.pages.contents.push(page);
return page;
};
state.mapNoteRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-note"));
state.notesReads = () => state.requests.filter((request) => request.href.includes("foundry/sync/notes"));
// The full note pulls, not the cheap revision pings the change check makes.
state.notesPulls = () => state.requests.filter((request) =>
request.href.includes("foundry/sync/notes") && !request.href.includes("/revision"));
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
// The reconciles `setInterval` registered: what runs every few seconds on a
// linked world, and so what carries each note into its journal page.
state.runIntervals = async () => {
for (const interval of [...state.intervals.values()]) await interval.fn();
await drain();
};
// Press a dice button the journal drew: the module listens on the document and
// finds the button through `closest`, like a click inside a journal page.
state.clickRoll = async (formula) => {
const button = { dataset: { dragonrollRoll: formula } };
const event = {
target: { closest: (selector) => (selector === "[data-dragonroll-roll]" ? button : null) },
defaultPrevented: false,
preventDefault() { this.defaultPrevented = true; },
};
for (const listener of state.clickListeners) await listener(event);
await drain();
return event;
};
state.linkedSetup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
state.requests.length = 0;
return state;
};
return state;
}
// The fetch stub updates a note with the page it maps, like the real backend
// does, so every test works on notes of its own.
const sessionNote = (over = {}) => ({ _id: "note-1", title: "Session 1", content: "**The start**", ...over });
const tavernNote = (over = {}) => ({ _id: "note-2", title: "Tavern Brawl", content: "A rope, a chandelier.", ...over });
test("the campaign's notes become pages of one Dragonroll journal", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "one journal carries the campaign's notes");
const journal = world.journals()[0];
assert.equal(journal.name, "Dragonroll");
assert.deepEqual(journal.pages.contents.map((page) => [page.name, page.text.content]), [
["Session 1", "<p><strong>The start</strong></p>"],
["Tavern Brawl", "<p>A rope, a chandelier.</p>"],
], "each note is a page, its markdown drawn into the page's HTML");
assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"],
"each page keeps the note it stands for");
assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [
["note-1", journal.pages.contents[0].id],
["note-2", journal.pages.contents[1].id],
], "and the campaign remembers each note's page");
});
test("notes in a folder share the journal named after its path", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [
sessionNote(),
{ _id: "note-2", title: "The road", content: "east", folder: "folder-1", folderPath: "Sessions" },
{ _id: "note-3", title: "The cave", content: "dark", folder: "folder-2", folderPath: "Sessions / Arc 1" },
];
await world.runIntervals();
const byName = new Map(world.journals().map((journal) => [journal.name, journal]));
assert.deepEqual([...byName.keys()].sort(), ["Dragonroll", "Sessions", "Sessions / Arc 1"],
"the root notes and each folder path get a journal of their own");
assert.deepEqual(byName.get("Dragonroll").pages.contents.map((page) => page.name), ["Session 1"]);
assert.deepEqual(byName.get("Sessions").pages.contents.map((page) => page.name), ["The road"]);
assert.deepEqual(byName.get("Sessions / Arc 1").pages.contents.map((page) => page.name), ["The cave"],
"a subfolder's notes stand in a journal named after the whole path");
assert.equal(byName.get("Sessions").getFlag(MODULE_ID, "notesFolder"), "folder-1",
"each folder journal keeps the folder it belongs to");
assert.equal(byName.get("Sessions / Arc 1").getFlag(MODULE_ID, "notesFolder"), "folder-2");
});
test("renaming a folder renames its journal", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [
{ _id: "note-1", title: "The road", content: "east", folder: "folder-1", folderPath: "Sessions" },
];
await world.runIntervals();
world.remoteNotes = [{ ...world.remoteNotes[0], folderPath: "Chapters" }];
await world.runIntervals();
assert.deepEqual(world.journals().map((journal) => journal.name), ["Chapters"],
"the journal follows the folder's path without being made again");
assert.equal(world.journals()[0].pages.contents.length, 1, "and its page stays where it was");
});
test("a note moved to another folder takes its page to that folder's journal", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [
{ _id: "note-1", title: "The road", content: "east", folder: "folder-1", folderPath: "Sessions" },
];
await world.runIntervals();
const firstPage = world.journals()[0].pages.contents[0];
world.remoteNotes = [{
...world.remoteNotes[0],
folder: "folder-2",
folderPath: "Sessions / Arc 1",
}];
await world.runIntervals();
assert.deepEqual(world.journals().map((journal) => journal.name), ["Sessions / Arc 1"],
"the journal the note left goes when it has nothing else in it");
const moved = world.journals()[0].pages.contents[0];
assert.equal(moved.name, "The road");
assert.notEqual(moved.id, firstPage.id, "the page is made in the journal the note moved to");
assert.equal(world.remoteNotes[0].foundryPageId, moved.id, "and the campaign maps the note to its new page");
});
test("reconciling again does not double the journal or its pages", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
await world.runIntervals();
await world.runIntervals();
assert.equal(world.journals().length, 1, "the journal is made once, not per reconcile");
assert.equal(world.journals()[0].pages.contents.length, 2, "and each note stands as the one page it was given");
assert.equal(world.mapNoteRequests().length, 2, "an already-mapped note is not mapped again");
});
test("an existing journal named Dragonroll is used, not doubled", async () => {
const world = await makeWorld().linkedSetup();
const gmsOwn = world.addJournal("Dragonroll");
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "the journal the world already had is the notes' one");
assert.deepEqual(gmsOwn.pages.contents.map((page) => page.name), ["Session 1"]);
assert.equal(gmsOwn.getFlag(MODULE_ID, "notesJournal"), true, "and it is marked, so renaming it keeps the notes' home findable");
});
test("extra journals named Dragonroll are removed before the notes are written", async () => {
const world = await makeWorld().linkedSetup();
const kept = world.addJournal("Dragonroll", { [MODULE_ID]: { notesJournal: true } });
const gmDuplicate = world.addJournal("Dragonroll");
const flaggedDuplicate = world.addJournal("Dragonroll", { [MODULE_ID]: { notesJournal: true } });
const unrelated = world.addJournal("Session Log");
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.deepEqual(world.journals(), [kept, unrelated],
"only the journal the reconcile writes into survives, beside the GM's other journals");
assert.deepEqual(kept.pages.contents.map((page) => page.name), ["Session 1"]);
assert.equal(gmDuplicate.pages.contents.length, 0);
assert.equal(flaggedDuplicate.pages.contents.length, 0);
assert.ok(unrelated, "a journal of another name is left alone");
});
test("several journals named Dragonroll collapse into the first one", async () => {
const world = await makeWorld().linkedSetup();
const first = world.addJournal("Dragonroll");
world.addJournal("Dragonroll");
world.addJournal("Dragonroll");
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.deepEqual(world.journals(), [first], "the duplicates go, the first one stays the notes' home");
assert.deepEqual(first.pages.contents.map((page) => page.name), ["Session 1"]);
assert.equal(first.getFlag(MODULE_ID, "notesJournal"), true);
});
test("a note edited in Dragonroll rewrites its page", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const first = world.remoteNotes[0];
world.remoteNotes = [{ ...first, title: "Session 1 — revisited", content: "**A different start**" }];
await world.runIntervals();
const journal = world.journals()[0];
assert.equal(journal.pages.contents.length, 1, "the note still stands as the same single page");
assert.deepEqual(journal.pages.contents[0].name, "Session 1 — revisited");
assert.equal(journal.pages.contents[0].text.content, "<p><strong>A different start</strong></p>");
assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping");
});
test("a note deleted in Dragonroll takes its page with it", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
const journal = world.journals()[0];
const gmsPage = world.addPage(journal, { name: "My own notes", text: { content: "not from Dragonroll" } });
world.remoteNotes = world.remoteNotes.filter((note) => note._id !== "note-2");
await world.runIntervals();
assert.deepEqual(journal.pages.contents.map((page) => page.name), ["Session 1", "My own notes"],
"the deleted note's page goes; the GM's own page stays");
assert.ok(journal.pages.contents.includes(gmsPage));
});
test("pages already in step with the campaign are not rewritten", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const [page] = world.journals()[0].pages.contents;
assert.equal(page.writes, 0, "the page was created whole, not patched");
await world.runIntervals();
assert.equal(page.writes, 0, "a reconcile that changes nothing leaves the page alone");
});
test("an unchanged campaign is not pulled over again", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.equal(world.notesPulls().length, 1, "the first reconcile pulls the notes");
await world.runIntervals();
assert.equal(world.notesPulls().length, 1,
"with the revision and the journal unchanged, only the cheap revision is asked for");
});
test("a page a GM edited is written back from the campaign's note", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const page = world.journals()[0].pages.contents[0];
page.name = "GM renamed it";
page.text.content = "GM wrote this";
await world.runIntervals();
assert.equal(page.name, "Session 1", "the campaign's title is written back over the GM's");
assert.equal(page.text.content, "<p><strong>The start</strong></p>", "and so is its content");
});
test("a journal page a GM removed is built again from the campaign's note", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
world.journals()[0].pages.contents.length = 0;
await world.runIntervals();
assert.deepEqual(world.journals()[0].pages.contents.map((entry) => entry.name), ["Session 1"],
"the journal holds the note's page again");
});
test("the campaign's page mapping claims a page whose flag was lost", async () => {
const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll");
const orphan = world.addPage(journal, { name: "Old name", text: { content: "old" } });
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: orphan.id }];
await world.runIntervals();
assert.equal(journal.pages.contents.length, 1, "no second page under the same title");
assert.equal(orphan.name, "Session 1");
assert.equal(orphan.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked again");
});
test("text that is not markdown is escaped, not injected", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }];
await world.runIntervals();
assert.equal(
world.journals()[0].pages.contents[0].text.content,
"<p>a &amp; b &lt; c<br />line two</p>\n<p>second para</p>",
"the raw text is escaped and stays legible",
);
});
test("a note's markdown is drawn into the page: headings, lists and marks", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{
_id: "note-1",
title: "Session 1",
content: "# Session One\n\n## The Tavern\n\n- rope\n- **torch**\n\n> danger\n\n---\n\n`code` and [a link](https://dragonroll.test)",
}];
await world.runIntervals();
assert.equal(
world.journals()[0].pages.contents[0].text.content,
"<h1>Session One</h1>\n"
+ "<h2>The Tavern</h2>\n"
+ "<ul>\n<li>rope</li>\n<li><strong>torch</strong></li>\n</ul>\n"
+ "<blockquote><p>danger</p></blockquote>\n"
+ "<hr />\n"
+ "<p><code>code</code> and <a href=\"https://dragonroll.test\">a link</a></p>",
"the note is drawn as the elements Foundry's journal styles know",
);
});
test("a note's dice widgets become buttons that roll in Foundry", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{
_id: "note-1",
title: "Goblin",
content: "The goblin attacks with @roll[1d20+4].\n\n@roll\n8d6\n@end",
}];
await world.runIntervals();
const html = world.journals()[0].pages.contents[0].text.content;
assert.match(html,
/<p>The goblin attacks with <button type="button" class="dragonroll-note-roll" data-dragonroll-roll="1d20\+4" title="Roll 1d20\+4"><i class="fa-solid fa-dice-d20" aria-hidden="true"><\/i><span>1d20\+4<\/span><\/button>\.<\/p>/,
"the inline widget is a button showing the expression the note wrote");
assert.match(html,
/<button type="button" class="dragonroll-note-roll dragonroll-note-roll-block" data-dragonroll-roll="8d6" title="Roll 8d6">/,
"the block widget is a button of its own, drawn full width");
const event = await world.clickRoll("1d20+4");
assert.equal(event.defaultPrevented, true, "the click does not navigate the journal");
assert.deepEqual(world.rollMessages.map((message) => message.formula), ["1d20+4"],
"pressing the button evaluates that expression in Foundry");
assert.equal(world.rollMessages[0].speaker.alias, "GM");
assert.match(world.rollMessages[0].flavor, /1d20\+4/,
"the chat card says the roll came from Dragonroll");
});
test("advantage and disadvantage become Foundry's keep-highest and keep-lowest", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{
_id: "note-1",
title: "Rolls",
content: "@roll[d20adv] @roll[2d20dis] @roll[4d6kh1]",
}];
await world.runIntervals();
const html = world.journals()[0].pages.contents[0].text.content;
assert.match(html, /data-dragonroll-roll="2d20kh1"/, "advantage rolls twice and keeps the higher die");
assert.match(html, /data-dragonroll-roll="2d20kl1"/, "disadvantage rolls twice and keeps the lower die");
assert.match(html, /data-dragonroll-roll="4d6kh1"/, "a keep-highest expression already reads as Foundry does");
});
test("a dice widget inside a code span stays text", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{ _id: "note-1", title: "Syntax", content: "`@roll[1d6]`" }];
await world.runIntervals();
assert.equal(world.journals()[0].pages.contents[0].text.content,
"<p><code>@roll[1d6]</code></p>",
"code that shows the widget syntax is not turned into a button");
});
// --- Wiki links and embeds in the journal page -----------------------------------
test("a note's [[links]] and ![[embeds]] become Foundry's own enrichers", async () => {
const world = await makeWorld().linkedSetup();
world.game.actors.contents.push({ id: "actor-1", name: "Mira", documentName: "Actor" });
world.game.items.contents.push({ id: "item-1", name: "Rope of Climbing", documentName: "Item" });
world.remoteNotes = [{
_id: "note-1",
title: "Links",
content: "[[Mira]] and ![[Mira]]\n\n[[Rope of Climbing]] and ![[Rope of Climbing]]",
}];
await world.runIntervals();
const html = world.journals()[0].pages.contents[0].text.content;
assert.match(html, /@UUID\[Actor\.actor-1\]\{Mira\}/,
"a link to a character opens it in Foundry");
assert.match(html, /@Embed\[Actor\.actor-1\]\{Mira\}/,
"an embedded character is drawn as a sheet preview");
assert.match(html, /@UUID\[Item\.item-1\]\{Rope of Climbing\}/,
"a link to an item opens it in Foundry");
assert.match(html, /@Embed\[Item\.item-1\]\{Rope of Climbing\}/,
"an embedded item is drawn as its sheet");
});
test("a name the world does not have is left dimmed, and only sheets can be embedded", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [{
_id: "note-1",
title: "Missing",
content: "[[Nobody]]\n\n![[Nobody]]\n\n![[Tavern Brawl]]",
}];
await world.runIntervals();
const html = world.journals()[0].pages.contents[0].text.content;
assert.match(html, /<span class="dragonroll-note-link is-unresolved">Nobody<\/span>/,
"an unresolved link still reads, but cannot be opened");
assert.match(html, /<span class="dragonroll-note-link is-unresolved">Tavern Brawl<\/span>/,
"a note written with the bang is not embedded as a sheet");
assert.doesNotMatch(html, /@Embed\[/, "nothing is embedded when there is no character or item");
});
test("a note can link to another note created in the same pull", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [
sessionNote({ content: "See [[Tavern Brawl]]." }),
tavernNote(),
];
await world.runIntervals();
const journal = world.journals()[0];
const sessionPage = journal.pages.contents.find((page) => page.name === "Session 1");
const tavernPage = journal.pages.contents.find((page) => page.name === "Tavern Brawl");
assert.match(
sessionPage.text.content,
new RegExp(`@UUID\\[JournalEntry\\.${journal.id}\\.JournalEntryPage\\.${tavernPage.id}\\]\\{Tavern Brawl\\}`),
"the page of the note it points at opens from the link"
);
});
test("autosync off: the campaign's notes are not written into the world", async () => {
const world = await makeWorld().linkedSetup();
await world.game.settings.set(MODULE_ID, "autoSync", false);
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.deepEqual(world.journals(), [], "no journal is made");
assert.deepEqual(world.notesReads(), [], "and the campaign is not even asked");
});

View File

@@ -35,15 +35,12 @@ function makeStubWorld({
linkCode = "",
linkUrl = "",
answers = {},
endpoint = "http://backend.test:5000",
} = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
menus: new Map(),
requests: [],
notifications: [],
copied: [],
};
const settingsStore = {
@@ -51,7 +48,7 @@ function makeStubWorld({
syncToken,
linkCode,
linkUrl,
dragonrollApiUrl: endpoint,
dragonrollApiUrl: "http://backend.test:5000",
};
const sandbox = {
@@ -59,10 +56,6 @@ function makeStubWorld({
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
// The module registers a menu for its connection actions: the window needs
// ApplicationV2 to exist, not to render.
foundry: { applications: { api: { ApplicationV2: class { render() {} } } } },
navigator: { clipboard: { writeText: async (text) => state.copied.push(text) } },
ui: {
notifications: {
info: (text) => state.notifications.push(["info", text]),
@@ -116,7 +109,6 @@ function makeStubWorld({
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
registerMenu(module, key, definition) { state.menus.set(key, definition); },
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
@@ -182,17 +174,6 @@ test("an unpaired world asks Dragonroll for a sign-up link and shows it", async
assert.equal(world.setting("linkCode"), "link-code-1", "the code behind the link is kept to ask with");
});
test("a local Dragonroll endpoint keeps the API path the backend mounts", async () => {
const world = await makeStubWorld({
syncToken: "",
endpoint: "http://localhost:5000",
answers: { "link/start": { status: "ok", code: "link-code-1", linkUrl: SIGN_UP_LINK } },
}).start();
assert.equal(world.linkStarts()[0].href, "http://localhost:5000/api/link/start",
"a local server is asked under /api like any other");
});
test("a world that holds a token neither asks for a link nor waits on one", async () => {
const world = await makeStubWorld({
answers: { "foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" } },
@@ -274,43 +255,6 @@ test("an expired link is replaced by one the GM can still open", async () => {
assert.match(world.status(), /link-code-2/, "and shows the new one");
});
test("the connection window copies the sign-up link", async () => {
const world = await makeStubWorld({
syncToken: "",
linkCode: "link-code-1",
linkUrl: SIGN_UP_LINK,
answers: { "link/pickup": { status: "ok", state: "pending" } },
}).start();
const menu = world.menus.get("pairingMenu");
assert.ok(menu, "the module settings open the connection window");
await menu.type.DEFAULT_OPTIONS.actions.copyLink.call(new menu.type());
assert.deepEqual(world.copied, [SIGN_UP_LINK], "the link waiting for its GM reaches the clipboard");
});
test("the connection window unlinks the campaign and asks for a fresh link", async () => {
const world = await makeStubWorld({
answers: {
"foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" },
"foundry/sync/unlink": { status: "ok" },
"link/start": { status: "ok", code: "link-code-2", linkUrl: SIGN_UP_LINK },
},
}).start();
assert.equal(world.status(), `Connected to the Dragonroll campaign "${LINKED_CAMPAIGN.name}".`);
const menu = world.menus.get("pairingMenu");
await menu.type.DEFAULT_OPTIONS.actions.unlink.call(new menu.type());
const unlink = world.requests.find((request) => request.href.includes("foundry/sync/unlink"));
assert.ok(unlink, "Dragonroll is told to forget this world");
assert.equal(unlink.body.worldId, "world-1");
assert.equal(unlink.authorization, "Bearer sync-token-1", "the world unlinks with the token it holds");
assert.equal(world.setting("syncToken"), "", "the token is dropped on this client too");
assert.equal(world.setting("linkCode"), "link-code-2", "a fresh link is kept ready to pair again");
assert.match(world.status(), /^Not connected yet/);
});
test("whatever is typed into the status is replaced by the real one", async () => {
const world = await makeStubWorld({
answers: { "foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" } },

View File

@@ -180,16 +180,11 @@ function makeStubWorld({ autoSync = true } = {}) {
}
async function forceSyncActors(world, ...actorIds) {
// Foundry 13+ hands the context menu hook the directory application and the
// menu items to mutate; selected entries carry their id on data-entry-id.
const entries = actorIds.map((actorId) => ({ dataset: { entryId: actorId } }));
const application = { element: { querySelectorAll: () => entries } };
const options = [];
await world.fire("getActorContextOptions", application, options);
const entry = options.find((option) => option.label === "Dragonroll: Force Sync");
await world.fire("getActorDirectoryEntryContext", null, options);
const entry = options.find((option) => option.name === "Dragonroll: Force Sync");
assert.ok(entry, "Dragonroll: Force Sync is offered in the actor directory context menu");
assert.ok(!entry.visible || entry.visible(), "the entry is visible for a linked GM world");
await entry.onClick(null, entries[0] ?? null);
await entry.callback(actorIds.map((actorId) => ({ dataset: { actorId } })));
await world.runTimers();
}
@@ -212,7 +207,6 @@ test("autosync on: Foundry CRUD events keep syncing with Dragonroll", async () =
const pushes = world.syncRequests();
assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.actors[0]._id, "actor-1");
assert.equal(pushes[0].body.replace, false, "a live actor change never asks Dragonroll to replace the campaign's edits");
});
test("autosync off: CRUD requests stop syncing", async () => {
@@ -266,7 +260,6 @@ test("force sync sends selected actors to Dragonroll even with autosync off", as
const pushes = world.syncRequests();
assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.fullSync, false, "a forced actor never prunes the campaign");
assert.equal(pushes[0].body.replace, true, "a forced sync replaces everything the campaign holds for those actors");
assert.deepEqual(pushes[0].body.actors.map((actor) => actor._id), ["actor-2"]);
assert.deepEqual(world.notifications.filter(([kind]) => kind !== "info"), []);
});

View File

@@ -132,8 +132,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
@@ -144,8 +142,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -1,153 +0,0 @@
// Tests for the note editor's wiki-link autocomplete (type `[[` while editing a note and the
// campaign's notes, actors, items and maps are offered to link to). The rules live in
// `frontend/app/services/LinkAutocomplete.js`, which imports nothing, so it is loaded straight from
// source; the fetching side, `LinkTargets.js`, is checked by reading it, because it talks to the API
// the repository root does not stand up.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
function loadLinkAutocomplete() {
const source = readRepoFile("frontend", "app", "services", "LinkAutocomplete.js");
return new Function(source.replace("export {", "return {"))();
}
const autocomplete = loadLinkAutocomplete();
// --- Finding the `[[target` the caret is in ---
test("typing after a [[ opens a trigger with what has been typed so far", () => {
assert.deepEqual(autocomplete.FindLinkTrigger("see [[The Wr", 12), { start: 4, query: "The Wr" });
assert.deepEqual(autocomplete.FindLinkTrigger("[[", 2), { start: 0, query: "" });
assert.deepEqual(autocomplete.FindLinkTrigger("a\n[[Mi", 6), { start: 2, query: "Mi" });
});
test("the trigger starts at the last [[ before the caret", () => {
assert.deepEqual(autocomplete.FindLinkTrigger("[[a [[b", 8), { start: 4, query: "b" });
});
test("a link is a single line, so a closed or newlined [[ opens nothing", () => {
// Caret after the closing brackets: the link is finished, not being typed.
assert.equal(autocomplete.FindLinkTrigger("[[The Inn]] ", 12), null);
assert.equal(autocomplete.FindLinkTrigger("[[The\nInn", 9), null);
assert.equal(autocomplete.FindLinkTrigger("no brackets here", 15), null);
assert.equal(autocomplete.FindLinkTrigger("", 0), null);
});
// --- The entries offered, from the campaign's four lists ---
test("every named note, actor, item and map becomes a suggestion, sorted by label", () => {
const suggestions = autocomplete.BuildLinkSuggestions({
notes: [{ _id: "n1", title: "The Wreck" }, { _id: "n2", title: " " }, { _id: "n3", title: "The Inn" }],
actors: [{ _id: "a1", name: "Mira" }],
items: [{ _id: "i1", name: "Rope" }],
maps: [{ _id: "m1", name: "Saltmarsh" }],
});
assert.deepEqual(suggestions, [
{ id: "a1", label: "Mira", type: "actor" },
{ id: "i1", label: "Rope", type: "item" },
{ id: "m1", label: "Saltmarsh", type: "map" },
{ id: "n3", label: "The Inn", type: "note" },
{ id: "n1", label: "The Wreck", type: "note" },
]);
});
test("entries without a name are left out, and a repeated label is offered once", () => {
const suggestions = autocomplete.BuildLinkSuggestions({
notes: [{ _id: "n1", title: "The Inn" }, { _id: "n2", title: "The Inn" }, { _id: "n3" }],
});
assert.deepEqual(suggestions, [{ id: "n1", label: "The Inn", type: "note" }]);
});
test("a campaign with no lists offers nothing", () => {
assert.deepEqual(autocomplete.BuildLinkSuggestions({}), []);
assert.deepEqual(autocomplete.BuildLinkSuggestions(undefined), []);
});
// --- Filtering what has been typed ---
test("the suggestions are filtered accent- and case-insensitively", () => {
const suggestions = [{ id: "n1", label: "Café", type: "note" }];
assert.equal(autocomplete.FilterLinkSuggestions(suggestions, "cafe").length, 1);
assert.equal(autocomplete.FilterLinkSuggestions(suggestions, "CAFÉ").length, 1);
assert.equal(autocomplete.FilterLinkSuggestions(suggestions, "tea").length, 0);
});
test("labels that start with what was typed come before the ones that only contain it", () => {
const suggestions = [
{ id: "n1", label: "The Inn", type: "note" },
{ id: "n2", label: "Innkeeper", type: "note" },
];
assert.deepEqual(
autocomplete.FilterLinkSuggestions(suggestions, "inn").map((s) => s.label),
["Innkeeper", "The Inn"]
);
});
test("an empty query offers the entries, capped so the menu stays short", () => {
const many = Array.from({ length: 60 }, (_, i) => ({ id: `n${i}`, label: `Note ${i}`, type: "note" }));
assert.equal(autocomplete.FilterLinkSuggestions(many, "").length, 50);
assert.equal(autocomplete.FilterLinkSuggestions([], "").length, 0);
});
// --- What is written when an entry is chosen ---
test("choosing an entry writes [[label]] and leaves the caret after the closing brackets", () => {
const trigger = autocomplete.FindLinkTrigger("see [[The Wr", 12);
const result = autocomplete.InsertLinkSuggestion("see [[The Wr", trigger, { label: "The Wreck" });
assert.equal(result.text, "see [[The Wreck]]");
assert.equal(result.caret, 17);
});
test("only the trigger is replaced, the note around it is kept", () => {
const trigger = autocomplete.FindLinkTrigger("a [[M b", 5);
const result = autocomplete.InsertLinkSuggestion("a [[M b", trigger, { label: "Mira" });
assert.equal(result.text, "a [[Mira]] b");
assert.equal(result.text.slice(0, result.caret) + "|" + result.text.slice(result.caret), "a [[Mira]]| b");
});
// --- The editor, the fetch and the menu are wired together ---
function wiringTests() {
const note = readRepoFile("frontend", "app", "components", "viewer", "content", "Note.vue");
const targets = readRepoFile("frontend", "app", "services", "LinkTargets.js");
test("the editor offers links through the service and the shared menu", () => {
assert.match(note, /from '~\/services\/LinkAutocomplete'/, "the editor reads the link autocomplete service");
assert.match(note, /from '~\/services\/LinkTargets'/, "…and the one that fetches the entries");
assert.match(note, /<SuggestionMenu/, "widgets and links share one menu");
assert.match(note, /@select="applySuggestion"/);
});
test("the entries a note can link to are the campaign's four lists", () => {
for (const path of ["/note/all", "/actor/list", "/item/list", "/map/list"]) {
assert.ok(targets.includes(path), `the link entries do not read ${path}`);
}
assert.match(targets, /CACHE_TTL/, "the four lists are cached instead of fetched per keystroke");
});
test("the link menu names its section in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const sections = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "campaigns.json")).sections;
for (const type of ["note", "actor", "item", "map"]) {
assert.ok(sections[`${type}s`], `${locale} has no label for the ${type} section`);
}
}
});
}
wiringTests();

View File

@@ -1,600 +0,0 @@
// Tests for the world's scenes arriving as the campaign's maps (Syndria98/dragonroll#99).
// Only a scene's background picture and the grid laid over it travel: the campaign keeps its
// own scale, its folders, its pinned notes and the tokens standing on the map, and none of it
// goes back to the world.
//
// Same set-up as tests/item-folder-sync.test.js, which the repository root runs without
// installing anything: the sync route is loaded into `node:vm` with express, mongoose and its
// models stubbed (plain rows and a small filter matcher), so creating, adopting and pruning
// maps is observable without a database. The Foundry module is loaded into a `node:vm` context
// holding stubbed Foundry globals (`game.scenes` included) with fake timers, like
// tests/foundry-sync-toggle.test.js.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
// --- The sync route against stubbed models -------------------------------------
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and
// lets `select()`, `sort()` and `limit()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
limit: (count) => mongooseQuery(value.slice(0, count)),
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Enough of the query language the scene sync uses: equality, $in, $nin, $exists.
// Anything else is a filter this test did not expect and says so.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
const value = document?.[key];
if (expected && typeof expected === "object" && !Array.isArray(expected)) {
return Object.entries(expected).every(([operator, wanted]) => {
if (operator === "$exists") return (value !== undefined && value !== null) === wanted;
if (operator === "$in") return wanted.some((entry) => String(value) === String(entry));
if (operator === "$nin") return !wanted.some((entry) => String(value) === String(entry));
throw new Error(`filter operator "${key}.${operator}" is not stubbed`);
});
}
return String(value ?? "") === String(expected ?? "");
});
}
function fakeModel(table, seed = [], campaignId) {
const rows = [];
let counter = 0;
function Document(data = {}) {
counter += 1;
this._id = `${table}-${counter}`;
this.isNew = true;
Object.assign(this, data);
}
Document.prototype.save = async function save() {
if (this.isNew) rows.push(this);
this.isNew = false;
return this;
};
Object.defineProperty(Document.prototype, "id", { get() { return this._id; } });
for (const data of seed) {
// A seeded row belongs to the campaign the requests are made against unless the seed
// says otherwise: the sync scopes every lookup by campaign.
const row = new Document({ campaign: campaignId, name: undefined, ...data });
row.isNew = false;
rows.push(row);
}
const model = function Model(data) { return new Document(data); };
model.rows = rows;
model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null;
model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter)));
model.deleteOne = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.deleteMany = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
return model;
}
// The Foundry sync route with every model it requires stubbed. `seed` pre-fills the tables
// with documents the campaign already holds.
function loadSyncRoute({ seed = {}, worldId = "world-1", settings } = {}) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const campaign = {
_id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId,
...(settings ? { settings } : {}),
};
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return { foundryItemToItemData: () => null };
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, body = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; }, set: () => {} };
const req = { body, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token" : "") };
await handlers[handlers.length - 1](req, res);
return res.payload;
}
return { call, models, campaign };
}
// A scene of the world, as the module sends it: plain document data with its picture read
// from the world. This one is 70 px cells and the picture of the ruined keep.
function worldScene(over = {}) {
return {
_id: "scene-1",
name: "The Ruined Keep",
img: "http://vtt.test/images/keep.webp",
grid: 70,
flags: {},
...over,
};
}
const maps = (sync) => sync.models["../models/Map"].rows;
// --- A scene arrives as a map -------------------------------------------------------
test("a world scene arrives as a map of the campaign", async () => {
const sync = loadSyncRoute();
const response = await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(response.status, "ok");
const [map] = maps(sync);
assert.equal(map.name, "The Ruined Keep");
assert.equal(map.image, "http://vtt.test/images/keep.webp", "the scene's background picture is the map's");
assert.equal(map.gridSize, 70, "the scene's own cell size is the grid the campaign draws");
assert.equal(map.offsetX, 0);
assert.equal(map.offsetY, 0, "a scene that shifts nothing has its grid at the corner of the picture");
assert.equal(map.foundrySceneId, "scene-1");
assert.equal(map.campaign, sync.campaign._id, "the map belongs to the campaign the world is linked to");
assert.deepEqual(response.maps, [{ foundrySceneId: "scene-1", mapId: map._id, created: true }]);
});
test("a scene keeps the grid its world shifted onto the picture", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ grid: 64, flags: { core: { shiftX: 12, shiftY: -8 } } })],
});
const [map] = maps(sync);
assert.equal(map.gridSize, 64);
assert.equal(map.offsetX, 12);
assert.equal(map.offsetY, -8, "a grid that starts off the corner of the picture arrives where the world puts it");
});
test("a scene of a newer Foundry still arrives", async () => {
const sync = loadSyncRoute();
// Since Foundry V13 the picture sits under `background.src` and the cell size under
// `grid.size`.
await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ img: undefined, background: { src: "http://vtt.test/images/keep.webp" }, grid: { size: 128 } })],
});
const [map] = maps(sync);
assert.equal(map.image, "http://vtt.test/images/keep.webp");
assert.equal(map.gridSize, 128);
});
test("a scene's picture is read against the world the campaign knows", async () => {
// An older module sends Foundry's own relative path; it is read against the world's
// address, the way an actor's portrait is (Syndria98/dragonroll#89).
const sync = loadSyncRoute({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene({ img: "images/keep.webp" })] });
assert.equal(maps(sync)[0].image, "http://vtt.test:30000/images/keep.webp");
});
test("a scene with no picture is not a map", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1", image: "http://vtt.test/images/keep.webp" }] },
});
// The GM took the picture off the scene: its id still travels with the snapshot, so its
// map is neither made blank nor dropped, and no new row is made for it either.
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ img: "" })],
fullSync: true,
});
assert.deepEqual(response.maps, []);
assert.equal(maps(sync).length, 1);
assert.equal(maps(sync)[0].image, "http://vtt.test/images/keep.webp");
});
test("what one of the map's cells stands for stays the campaign's", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1", gridSize: 50, scale: 1.5 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene({ gridDistance: 1500, gridUnits: "m" })] });
assert.equal(maps(sync)[0].gridSize, 70, "the world's cell size arrives");
assert.equal(maps(sync)[0].scale, 1.5, "and the distance the campaign says a cell covers is left alone");
});
// --- One map per scene ---------------------------------------------------------------
test("the same scene is never made into two maps", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ name: "The Ruined Keep, II", grid: 80 })],
});
assert.equal(maps(sync).length, 1, "the scene was written over, not doubled");
assert.equal(maps(sync)[0].name, "The Ruined Keep, II");
assert.equal(maps(sync)[0].gridSize, 80);
assert.equal(response.maps[0].created, false, "the push says it wrote a map it already had");
});
test("a live scene edit lands on the map, however the campaign had it", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "Old name", foundrySceneId: "scene-1", image: "old.png", gridSize: 40 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
const [map] = maps(sync);
assert.equal(map.image, "http://vtt.test/images/keep.webp");
assert.equal(map.gridSize, 70);
assert.equal(map.name, "The Ruined Keep");
});
test("a full snapshot leaves the picture and grid the campaign lined up alone", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "My keep", foundrySceneId: "scene-1", image: "my-keep.png", gridSize: 40 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()], fullSync: true });
const [map] = maps(sync);
assert.equal(map.image, "my-keep.png", "a GM reconnecting does not write over a map the campaign already had");
assert.equal(map.gridSize, 40);
assert.equal(map.name, "My keep");
});
test("a scene takes over the map the campaign drew by hand", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", image: "hand-made.png", gridSize: 50 }] },
});
const response = await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(maps(sync).length, 1, "the room the campaign drew first is not doubled by its scene");
assert.equal(maps(sync)[0]._id, "map-1");
assert.equal(maps(sync)[0].foundrySceneId, "scene-1", "and it is the scene's map from then on");
assert.equal(response.maps[0].mapId, "map-1");
});
test("a scene carrying the campaign's map id adopts that row", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-0123456789abcdef0123456789", name: "Keep under way", image: "hand-made.png" }] },
});
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ name: "Somewhere else", flags: { "dragonroll-foundry": { mapId: "map-0123456789abcdef0123456789" } } })],
});
assert.equal(maps(sync).length, 1);
assert.equal(response.maps[0].mapId, "map-0123456789abcdef0123456789", "the flag says which map the scene is");
});
// --- Pruning --------------------------------------------------------------------------
test("a full snapshot prunes the maps whose scene this world let go of", async () => {
const sync = loadSyncRoute({
seed: {
maps: [
{ _id: "map-1", name: "Cellar", foundrySceneId: "scene-gone" },
{ _id: "map-2", name: "Homebrew ford" },
{ _id: "map-3", name: "The Ruined Keep", foundrySceneId: "scene-1" },
],
},
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()], fullSync: true });
assert.deepEqual(maps(sync).map((map) => map._id).sort(), ["map-2", "map-3"],
"the scene that is gone takes its map with it, and the campaign's own maps stay");
});
test("a live scene push never prunes", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "Cellar", foundrySceneId: "scene-gone" }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(maps(sync).length, 2, "a push of one scene says nothing about the world's other scenes");
});
test("a scene the world deleted takes its map with it", async () => {
const sync = loadSyncRoute({
seed: {
maps: [
{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1" },
{ _id: "map-2", name: "Homebrew ford" },
],
},
});
const response = await sync.call("POST /sync/scene-delete", { worldId: "world-1", foundrySceneId: "scene-1" });
assert.equal(response.status, "ok");
assert.deepEqual(maps(sync).map((map) => map._id), ["map-2"], "only the map of that scene goes");
});
// --- What the route refuses -----------------------------------------------------------
test("a push that is not the campaign's world, or names no scenes, is refused", async () => {
const sync = loadSyncRoute();
assert.equal((await sync.call("POST /sync/scenes", { worldId: "another-world", scenes: [worldScene()] })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/scenes", { worldId: "world-1" })).msg, "errors.missing-data");
assert.deepEqual(maps(sync), [], "nothing was written");
});
test("a delete from another world, or naming no scene, is refused", async () => {
const sync = loadSyncRoute({ seed: { maps: [{ _id: "map-1", name: "Keep", foundrySceneId: "scene-1" }] } });
assert.equal((await sync.call("POST /sync/scene-delete", { worldId: "another-world", foundrySceneId: "scene-1" })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/scene-delete", { worldId: "world-1" })).msg, "errors.missing-data");
assert.equal(maps(sync).length, 1, "and the map is still there");
});
test("a map remembers which scene of the world it mirrors", () => {
const model = read("backend", "src", "models", "Map.js");
assert.match(model, /foundrySceneId:\s*{\s*type:\s*String\s*}/, "the scene a map mirrors is kept on the map");
assert.match(model, /\{\s*campaign:\s*1,\s*foundrySceneId:\s*1\s*\}/, "and is unique within the campaign");
});
// --- The Foundry module sends its scenes ---------------------------------------------
const MODULE_ID = "dragonroll-foundry";
function makeWorld({ autoSync = true } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
intervals: new Map(),
nextTimerId: 1,
};
// A Scene document: the plain data `toObject()` answers with, which since V13 carries
// the picture under `background` rather than `img`.
const makeScene = (id, name, over = {}) => ({
id, name, documentName: "Scene", img: "", grid: 50, flags: {},
toObject() {
return {
_id: this.id, name: this.name, img: this.img, grid: this.grid, flags: this.flags,
...(this.background ? { background: this.background } : {}),
};
},
...over,
});
const scenes = [
makeScene("scene-keep", "The Ruined Keep", { img: "images/keep.webp", grid: 70 }),
// A newer Foundry keeps its picture under `background`, and this one is already an
// absolute URL, which travels as it is.
makeScene("scene-tavern", "Tavern", { img: undefined, background: { src: "http://other.test/tavern.jpg" }, grid: 50 }),
];
const settingsStore = { autoSync, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
ui: { notifications: { info() {}, warn() {}, error() {} } },
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); },
},
setTimeout: (fn, delay = 0) => {
const id = state.nextTimerId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: (fn, delay = 0) => {
const id = state.nextTimerId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
fetch: async (url, options = {}) => {
state.requests.push({
href: String(url),
method: options.method,
body: options.body ? JSON.parse(options.body) : null,
});
return { ok: true, status: 200, json: async () => ({ status: "ok" }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: [], get: () => null },
items: { contents: [], get: () => null },
scenes: { contents: scenes, get: (id) => scenes.find((scene) => scene.id === id) },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.scene = (id) => scenes.find((scene) => scene.id === id);
// The two routes the maps travel on: the campaign's reads live under the same prefix and
// tell nothing about what the world sent.
state.sceneRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/scenes")
|| request.href.includes("foundry/sync/scene-delete"));
state.pushes = (route) => state.requests.filter((request) => request.href.includes(route));
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
// A world that is already linked: init, ready, and the pushes the world makes as it loads.
state.setup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
return state;
};
// The same, with the world's own pushes out of the way, so a test only sees what it causes.
state.linkedSetup = async () => {
await state.setup();
state.requests.length = 0;
return state;
};
return state;
}
test("the world sends its whole scene list as the campaign's maps when it loads", async () => {
const world = await makeWorld().setup();
const [push] = world.pushes("foundry/sync/scenes");
assert.ok(push, "a linked world pushes its scenes as it loads");
assert.equal(push.body.fullSync, true, "the whole list travels, which is the push that lets the campaign prune");
assert.deepEqual(push.body.worldId, "world-1");
assert.deepEqual(push.body.scenes.map((scene) => [scene._id, scene.name]), [
["scene-keep", "The Ruined Keep"],
["scene-tavern", "Tavern"],
]);
assert.equal(push.body.scenes[0].img, "http://vtt.test/images/keep.webp",
"the picture is read from this world, so it travels as an absolute URL");
assert.equal(push.body.scenes[0].grid, 70, "the scene's own cell size travels with it");
assert.equal(push.body.scenes[1].background.src, "http://other.test/tavern.jpg",
"a picture that is already absolute is left as it is");
});
test("a scene the GM changes reaches the campaign as that map", async () => {
const world = await makeWorld().linkedSetup();
const keep = world.scene("scene-keep");
keep.name = "The Sunken Keep";
keep.grid = 100;
await world.fire("updateScene", keep);
await world.runTimers();
const [push] = world.pushes("foundry/sync/scenes");
assert.equal(push.body.fullSync, false, "a live scene edit never prunes the campaign's other maps");
assert.deepEqual(push.body.scenes.map((scene) => [scene._id, scene.name, scene.grid]), [
["scene-keep", "The Sunken Keep", 100],
]);
});
test("a scene the GM deletes takes its map off the campaign", async () => {
const world = await makeWorld().linkedSetup();
await world.fire("deleteScene", world.scene("scene-tavern"));
await world.runTimers();
const [push] = world.pushes("foundry/sync/scene-delete");
assert.equal(push.body.foundrySceneId, "scene-tavern");
assert.deepEqual(world.pushes("foundry/sync/scenes"), [], "a deleted scene is not sent as a map to keep");
});
test("autosync off: the world's scenes stop syncing, at world start and afterwards", async () => {
const world = makeWorld({ autoSync: false });
await world.fire("init");
await world.fire("ready");
await world.runTimers();
assert.deepEqual(world.sceneRequests(), [], "a world with autosync off sends no scene list");
await world.fire("updateScene", world.scene("scene-keep"));
await world.fire("deleteScene", world.scene("scene-tavern"));
await world.runTimers();
assert.deepEqual(world.sceneRequests(), []);
});
test("the scene edits queued while autosync was off are sent when it is turned back on", async () => {
const world = await makeWorld({ autoSync: false });
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateScene", world.scene("scene-keep"));
await world.runTimers();
assert.deepEqual(world.sceneRequests(), []);
await world.game.settings.set(MODULE_ID, "autoSync", true);
await world.runTimers();
assert.ok(world.pushes("foundry/sync/scenes").some((push) => push.body.fullSync === true
&& push.body.scenes.length === 2),
"turning autosync back on sends this world's whole scene list again");
assert.ok(world.pushes("foundry/sync/scenes").some((push) => push.body.fullSync === false
&& push.body.scenes.map((scene) => scene._id).includes("scene-keep")),
"and the scene edit queued while it was off is sent");
});

699
tests/map-walls.test.js Normal file
View File

@@ -0,0 +1,699 @@
// Tests for the walls of maps (Syndria98/dragonroll#100): a wall editor on the map viewer, the
// walls kept on the map document, and the sync that lets a paired Foundry scene and a campaign
// map trade the same segments.
//
// Like map-pins.test.js, the express routers run against a stubbed `require` inside `node:vm`,
// the `MapWalls.js` service is loaded the way the map tests load the other services, and the
// Foundry module is loaded into a stubbed Foundry world whose embedded-document writes are
// observable. The last checks read the template of the map viewer, because there the wiring
// itself is what has to stay right.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const MODULE_ID = "dragonroll-foundry";
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and lets
// `select()` and `sort()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Loads an express router file with every module it requires stubbed out: `stubs` maps a require
// path to the module the route should see.
function loadRouter(relativeParts, stubs) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../services/storage") return { single: () => (req, res, next) => next() };
if (!(id in stubs)) throw new Error(`require("${id}") is not stubbed`);
return stubs[id];
};
const moduleStub = { exports: {} };
vm.compileFunction(readRepoFile(...relativeParts), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, { body = {}, query = {}, params = {}, user = { id: "user-1" }, get = () => "" } = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; } };
await handlers[handlers.length - 1]({ body, query, params, user, get }, res);
return res.payload;
}
return { routes, call };
}
// --- POST /map/walls: the wall editor's save ------------------------------------------------
function makeMapDoc(walls = []) {
return { _id: "map-1", campaign: "campaign-1", walls, save: async () => {} };
}
function loadMapRoutes({ ownsCampaign = true, maps = [] } = {}) {
return loadRouter(["backend", "src", "routes", "map.js"], {
"../models/Campaign": { findOne: () => mongooseQuery(ownsCampaign ? { _id: "campaign-1" } : null) },
"../models/Map": { findById: (id) => mongooseQuery(maps.find((map) => map._id === id) ?? null) },
"../models/Note": { findOne: () => mongooseQuery(null) },
"../models/Actor": { findOne: () => mongooseQuery(null) },
"../models/Folder": { find: () => mongooseQuery([]), belongsToSection: async () => true },
});
}
function wallSaveRouteTests() {
test("the wall editor saves the whole set, sanitised to whole image pixels", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
const response = await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
// Coordinates arrive as strings from a form-ish body and can leave the image.
{ x1: "10.4", y1: -8, x2: 50, y2: 50.5, move: false },
{ _id: "wall-2", x1: 100, y1: 0, x2: 100, y2: 75, door: 2 },
],
},
});
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [
{ x1: 10, y1: 0, x2: 50, y2: 51, move: false, sight: true, door: 0 },
{ _id: "wall-2", x1: 100, y1: 0, x2: 100, y2: 75, move: true, sight: true, door: 2 },
]);
});
test("a save replaces the set: walls the editor dropped are gone", async () => {
const map = makeMapDoc([
{ _id: "wall-1", x1: 0, y1: 0, x2: 50, y2: 0 },
{ _id: "wall-2", x1: 0, y1: 0, x2: 0, y2: 50 },
]);
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", { body: { id: "map-1", walls: [{ _id: "wall-2", x1: 5, y1: 5, x2: 0, y2: 60 }] } });
assert.deepEqual(map.walls.map((wall) => String(wall._id)), ["wall-2"]);
assert.equal(map.walls[0].y1, 5);
});
test("segments without length or with unreadable endpoints are dropped", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
{ x1: 40, y1: 40, x2: 40, y2: 40 },
{ x1: "wide", y1: 0, x2: 50, y2: 50 },
{ x1: 0, y1: 0, x2: 50, y2: 50 },
],
},
});
assert.equal(map.walls.length, 1);
});
test("an unknown _id does not smuggle an id into the set, and a door outside 1 and 2 is no door", async () => {
const map = makeMapDoc([{ _id: "wall-1", x1: 0, y1: 0, x2: 50, y2: 0 }]);
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
{ _id: "wall-9", x1: 0, y1: 0, x2: 50, y2: 0, door: 5 },
{ _id: "wall-1", x1: 60, y1: 0, x2: 60, y2: 50, door: "1" },
],
},
});
assert.deepEqual(map.walls, [
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 0 },
{ _id: "wall-1", x1: 60, y1: 0, x2: 60, y2: 50, move: true, sight: true, door: 1 },
]);
});
test("saving walls needs the map and an array, and only of one's own campaign", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
const foreign = loadMapRoutes({ ownsCampaign: false, maps: [makeMapDoc()] });
assert.equal((await api.call("POST /walls", { body: { walls: [] } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-1" } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-1", walls: "nope" } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-404", walls: [] } })).msg, "errors.notfound");
assert.equal((await foreign.call("POST /walls", { body: { id: "map-1", walls: [] } })).msg, "unauthorized");
assert.deepEqual(map.walls, []);
});
}
// --- The module's sync routes: pairing a scene and trading wall sets -------------------------
function loadSyncRoutes({ campaign = { _id: "campaign-1", foundryWorldId: "world-1", settings: {} }, maps = [] } = {}) {
const matches = (map, filter) => {
if (filter._id !== undefined) {
if (typeof filter._id === "object" && filter._id.$ne !== undefined) {
if (String(map._id) === String(filter._id.$ne)) return false;
} else if (String(map._id) !== String(filter._id)) return false;
}
if (filter.campaign !== undefined && String(map.campaign) !== String(filter.campaign)) return false;
if (filter.foundrySceneId !== undefined
&& String(map.foundrySceneId ?? "") !== String(filter.foundrySceneId)) return false;
return true;
};
return loadRouter(["backend", "src", "routes", "foundry-link.js"], {
"node:crypto": require("node:crypto"),
mongoose: { isValidObjectId: () => false },
"../models/Campaign": { findOne: () => mongooseQuery(campaign) },
"../models/Actor": { find: () => mongooseQuery([]), findOne: () => mongooseQuery(null) },
"../models/Item": { find: () => mongooseQuery([]), findOne: () => mongooseQuery(null) },
"../models/Folder": { find: () => mongooseQuery([]) },
"../models/Map": {
find: (filter) => mongooseQuery(maps.filter((map) => matches(map, filter))),
findOne: (filter) => mongooseQuery(maps.find((map) => matches(map, filter)) ?? null),
},
"../services/actor-foundry": { foundryActorToCharacter: () => ({}) },
"../services/item-foundry": { foundryItemToItemData: () => null },
"../services/foundry-icons": { joinFoundryAssetUrl: () => "" },
});
}
// The sync routes authenticate with the token, not a JWT.
function asModule(request) {
return { ...request, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token-1" : "") };
}
function syncRoutesTests() {
test("the module reads the campaign's maps with their walls and pairings", async () => {
const maps = [
{ _id: "map-1", campaign: "campaign-1", name: "Dungeon", image: "d.png", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 0 }] },
{ _id: "map-2", campaign: "campaign-1", name: "Town", image: "", foundrySceneId: null, walls: [] },
];
const api = loadSyncRoutes({ maps });
const response = await api.call("GET /sync/maps", asModule({}));
assert.equal(response.status, "ok");
assert.deepEqual(response.maps.map((map) => map.name), ["Dungeon", "Town"]);
assert.deepEqual(response.maps[0].walls, [{ x1: 0, y1: 0, x2: 50, y2: 0 }]);
});
test("a paired scene's whole wall set replaces the map's, sanitised", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 9, y1: 9, x2: 9, y2: 60 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const response = await api.call("POST /sync/map-walls", asModule({
body: {
worldId: "world-1",
foundrySceneId: "scene-1",
walls: [
{ x1: 10.4, y1: -3, x2: 60, y2: 50.5, move: true, sight: false, door: 0 },
{ x1: 0, y1: 0, x2: 0, y2: 0, door: 2 },
{ x1: 0, y1: 0, x2: 50, y2: 0, door: 1 },
],
},
}));
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [
{ x1: 10, y1: 0, x2: 60, y2: 51, move: true, sight: false, door: 0 },
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 1 },
]);
});
test("a scene with no paired map answers notfound and changes no map", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 50 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const response = await api.call("POST /sync/map-walls", asModule({
body: { worldId: "world-1", foundrySceneId: "scene-2", walls: [] },
}));
assert.equal(response.msg, "errors.notfound");
assert.equal(map.walls.length, 1);
});
test("the wall push needs the paired world, the scene and an array", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 50 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const wrongWorld = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-2", foundrySceneId: "scene-1", walls: [] } }));
const noScene = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-1", walls: [] } }));
const noWalls = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-1", foundrySceneId: "scene-1" } }));
assert.deepEqual([wrongWorld.msg, noScene.msg, noWalls.msg], ["errors.missing-data", "errors.missing-data", "errors.missing-data"]);
assert.equal(map.walls.length, 1);
});
test("an unauthenticated module hears nothing but unauthorized", async () => {
const api = loadSyncRoutes({ maps: [] });
const response = await api.call("GET /sync/maps", { get: () => "" });
assert.equal(response.msg, "unauthorized");
});
test("pairing a map with a scene records it, and one scene walls one map at most", async () => {
const maps = [
{ _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: null, walls: [], save: async () => {} },
{ _id: "map-2", campaign: "campaign-1", name: "Crypt", foundrySceneId: "scene-1", walls: [], save: async () => {} },
];
const api = loadSyncRoutes({ maps });
const taken = await api.call("POST /sync/map-scene", asModule({ body: { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-1" } }));
assert.equal(taken.msg, "foundry.errors.scene-already-synced");
assert.equal(maps[0].foundrySceneId, null);
const paired = await api.call("POST /sync/map-scene", asModule({ body: { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-7" } }));
assert.equal(paired.status, "ok");
assert.equal(maps[0].foundrySceneId, "scene-7");
});
}
// --- The MapWalls service: snapping and drawing ---------------------------------------------
function loadMapWallsService() {
const source = readRepoFile("frontend", "app", "services", "MapWalls.js");
const body = source.replace(/export\s*\{/, "return {").concat("\n;");
return vm.compileFunction(body, [])();
}
function mapWallsServiceTests() {
const service = loadMapWallsService();
// 800x600 image, shown at 200% and panned so its top left corner sits at (20, 10) of the viewport.
const view = { zoom: 2, pan: { x: 20, y: 10 }, width: 800, height: 600 };
const grid = { gridSize: 50, offsetX: 10, offsetY: 0 };
test("a spot of the viewport becomes the image pixel it stands for, clamped but never refused", () => {
assert.deepEqual(service.ToDrawPoint({ x: 100, y: 50 }, view), { x: 40, y: 20 });
// A drag over the edge keeps drawing at the edge instead of dropping the wall.
assert.deepEqual(service.ToDrawPoint({ x: 0, y: 50 }, view), { x: 0, y: 20 });
assert.equal(service.ToDrawPoint({ x: 100, y: 50 }, { zoom: 0, pan: { x: 0, y: 0 } }), null);
});
test("endpoints snap to the nearest grid intersection, offset included", () => {
assert.deepEqual(service.SnapToGrid({ x: 112, y: 24 }, grid), { x: 110, y: 0 });
assert.deepEqual(service.SnapToGrid({ x: 112, y: 26 }, grid), { x: 110, y: 50 });
assert.deepEqual(service.SnapToGrid({ x: -8, y: -8 }, grid), { x: 0, y: 0 });
assert.equal(service.SnapToGrid(null, grid), null);
});
test("a wall becomes the screen line that draws it", () => {
assert.deepEqual(service.ToScreenWall({ x1: 40, y1: 20, x2: 90, y2: 70 }, view), { x1: 100, y1: 50, x2: 200, y2: 150 });
assert.deepEqual(service.ToScreenWall({}, view), { x1: 20, y1: 10, x2: 20, y2: 10 });
});
test("a slid wall keeps its shape and goes nowhere off the image", () => {
assert.deepEqual(service.MoveWall({ x1: 10, y1: 10, x2: 60, y2: 10 }, 13.4, -5.6), { x1: 23, y1: 4, x2: 73, y2: 4 });
assert.deepEqual(service.MoveWall({ x1: 5, y1: 5, x2: 5, y2: 55 }, -10, 0), { x1: 0, y1: 0, x2: 0, y2: 50 });
assert.equal(service.MoveWall({ x1: 0, y1: 0, x2: 5, y2: 5 }, "x", 0), null);
});
test("a segment with no length is no wall", () => {
assert.equal(service.IsWall({ x1: 40, y1: 40, x2: 41, y2: 40 }), true);
assert.equal(service.IsWall({ x1: 40, y1: 40, x2: 40, y2: 40 }), false);
assert.equal(service.IsWall(null), false);
assert.equal(service.IsWall({ x1: 0, y1: 0, x2: 0 }), false);
});
}
// --- The Foundry module: pairing scenes, trading wall sets -----------------------------------
function makeWallWorld({ autoSync = true, maps = [], scenes = [], pairedSceneIds = null } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
notifications: [],
timers: new Map(),
nextTimerId: 1,
maps,
embeddedWrites: [],
pairedSceneIds,
};
const settingsStore = {
autoSync,
syncToken: "sync-token-1",
dragonrollApiUrl: "http://backend.test:5000",
};
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
ui: {
notifications: {
info: (text) => state.notifications.push(["info", text]),
warn: (text) => state.notifications.push(["warn", text]),
error: (text) => state.notifications.push(["error", text]),
},
},
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) {
const handlers = state.hooks.get(name) || [];
handlers.push(fn);
state.hooks.set(name, handlers);
},
},
setTimeout: (fn, delay = 0) => {
const id = state.nextTimerId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
const href = String(url);
const body = options.body ? JSON.parse(options.body) : null;
state.requests.push({ href, method: options.method, body });
if (href.includes("foundry/sync/maps")) {
return { ok: true, status: 200, json: async () => ({ status: "ok", maps: state.maps }) };
}
if (href.includes("foundry/sync/map-walls") && state.pairedSceneIds
&& !state.pairedSceneIds.includes(body?.foundrySceneId)) {
return { ok: true, status: 200, json: async () => ({ status: "error", msg: "errors.notfound" }) };
}
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [], folders: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: [], get: () => null },
items: { contents: [], get: () => null },
folders: { contents: [] },
scenes: { contents: scenes, get: (id) => scenes.find((scene) => scene.id === id) },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(readRepoFile("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
// A scene holding Foundry-shape wall documents. Its embedded writes are recorded, and —
// like the real client — each one fires the scene's wall hooks while the write is under way.
state.makeScene = (id, name, walls = []) => {
const scene = {
id, name, documentName: "Scene",
wallDocuments: { contents: walls },
async updateEmbeddedDocuments(kind, updates) {
state.embeddedWrites.push([kind, "update", updates]);
for (const update of updates) {
const wall = walls.find((current) => current.id === update._id);
const { _id, ...rest } = update;
Object.assign(wall, rest);
}
await state.fireSync("updateWall", walls.map((wall) => ({ documentName: "Wall", id: wall.id, parent: scene })));
},
async createEmbeddedDocuments(kind, creates) {
state.embeddedWrites.push([kind, "create", creates]);
const created = creates.map((data, index) => ({ id: `${id}-wall-${index}`, ...data }));
walls.push(...created);
await state.fireSync("createWall", created.map((wall) => ({ documentName: "Wall", id: wall.id, parent: scene })));
},
async deleteEmbeddedDocuments(kind, ids) {
state.embeddedWrites.push([kind, "delete", ids]);
for (const documentId of ids) {
const index = walls.findIndex((wall) => wall.id === documentId);
if (index >= 0) walls.splice(index, 1);
}
await state.fireSync("deleteWall", ids.map((documentId) => ({ documentName: "Wall", id: documentId, parent: scene })));
},
};
return scene;
};
// Fire a wall hook through the sandboxed Hooks registry without awaiting each handler: the
// real client fires wall hooks synchronously while a write runs.
state.fireSync = (name, documents) => {
for (const handler of state.hooks.get(name) || []) {
for (const document of documents) handler(document);
}
};
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 8; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
async function drain() {
await new Promise((resolve) => setImmediate(resolve));
}
state.linkedSetup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
state.requests.length = 0;
state.embeddedWrites.length = 0;
return state;
};
state.wallPushes = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-walls"));
state.scenePairings = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-scene"));
return state;
}
function foundryModuleWallTests() {
test("a GM's wall edit pushes the scene's whole set, in the campaign's shape", async () => {
const scene = makeWallWorld().makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [10.4, -3, 60, 50.5], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-2", c: [0, 0, 50, 0], light: 0, sense: 0, move: 0, door: 2, ds: 1 },
]);
const world = await scene.linkedSetup();
await world.fire("updateWall", { documentName: "Wall", id: "wall-2", parent: scene });
await world.runTimers();
const pushes = world.wallPushes();
assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.foundrySceneId, "scene-1");
assert.deepEqual(pushes[0].body.walls, [
{ x1: 10, y1: 0, x2: 60, y2: 51, move: true, sight: true, door: 0 },
{ x1: 0, y1: 0, x2: 50, y2: 0, move: false, sight: false, door: 1 },
]);
assert.deepEqual(world.embeddedWrites, []);
});
test("the campaign's set lands on its paired scene: changed walls written, extra ones deleted", async () => {
const world = makeWallWorld({
maps: [{
_id: "map-1", name: "Dungeon", foundrySceneId: "scene-1",
walls: [
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 0 },
{ x1: 50, y1: 0, x2: 50, y2: 100, move: false, sight: true, door: 2 },
],
}],
scenes: [],
});
const scene = world.makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [0, 0, 50, 0], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-2", c: [0, 0, 0, 80], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-3", c: [90, 90, 120, 90], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
// wall-1 already stands where the campaign wants it and is left alone; wall-2 is
// retyped into the campaign's second segment; wall-3 is beyond the set and goes.
const updates = world.embeddedWrites.find(([, kind, payload]) => kind === "update" && payload.length)?.[2];
assert.deepEqual(updates, [{
_id: "wall-2", c: [50, 0, 50, 100], light: 2, sense: 2, move: 0, door: 2, ds: 0,
}]);
const deletes = world.embeddedWrites.find(([, kind, payload]) => kind === "delete")?.[2];
assert.deepEqual(deletes, ["wall-3"]);
// The set landed on the scene is exactly the campaign's: it reads back unchanged, so the
// writes are not echoed to the campaign.
assert.deepEqual(world.wallPushes(), []);
});
test("a map with no walls adopts the walls the scene already has", async () => {
const world = makeWallWorld({
maps: [{ _id: "map-1", name: "Crypt", foundrySceneId: "scene-1", walls: [] }],
scenes: [],
});
const scene = world.makeScene("scene-1", "Crypt", [
{ id: "wall-1", c: [0, 0, 100, 0], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
const pushes = world.wallPushes();
assert.equal(pushes.length, 1);
assert.deepEqual(pushes[0].body.walls, [
{ x1: 0, y1: 0, x2: 100, y2: 0, move: true, sight: true, door: 0 },
]);
assert.deepEqual(world.embeddedWrites, []);
});
test("a campaign map pairs with the scene of its name, and only when it is the only one", async () => {
const paired = makeWallWorld({
maps: [{ _id: "map-1", name: "Dungeon", foundrySceneId: null, walls: [{ x1: 10, y1: 10, x2: 60, y2: 60 }] }],
scenes: [],
});
const scene = paired.makeScene("scene-1", "Dungeon", []);
paired.game.scenes.contents.push(scene);
await paired.fire("init");
await paired.fire("ready");
await paired.runTimers();
const pairings = paired.scenePairings();
assert.equal(pairings.length, 1);
assert.deepEqual(pairings[0].body, { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-1" });
// Paired, the campaign's wall lands as a new wall document on the scene.
const creates = paired.embeddedWrites.find(([, kind, payload]) => kind === "create")?.[2];
assert.deepEqual(creates, [{ c: [10, 10, 60, 60], light: 2, sense: 2, move: 1, door: 0, ds: 0 }]);
// Two scenes share the name: the map is nobody's by name alone, and nothing is paired or written.
const twin = makeWallWorld({
maps: [{ _id: "map-1", name: "Dungeon", foundrySceneId: null, walls: [{ x1: 10, y1: 10, x2: 60, y2: 60 }] }],
scenes: [],
});
twin.game.scenes.contents.push(twin.makeScene("scene-1", "Dungeon", []), twin.makeScene("scene-2", "Dungeon", []));
await twin.fire("init");
await twin.fire("ready");
await twin.runTimers();
assert.deepEqual(twin.scenePairings(), []);
assert.deepEqual(twin.embeddedWrites, []);
});
test("a scene no campaign map mirrors is let go of, not retried", async () => {
const world = makeWallWorld({ pairedSceneIds: [] });
const scene = world.makeScene("scene-9", "Not a map", [
{ id: "wall-1", c: [0, 0, 50, 50], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
await world.linkedSetup();
world.game.scenes.contents.push(scene);
await world.fire("createWall", { documentName: "Wall", id: "wall-1", parent: scene });
await world.runTimers();
// The push was made once and, hearing the campaign keeps no map for this scene, the
// module stops asking about it again.
assert.equal(world.wallPushes().length, 1);
assert.deepEqual(world.notifications.filter(([kind]) => kind === "error"), []);
});
test("autosync off keeps walls at home, and on again reconciles them", async () => {
const world = makeWallWorld({ autoSync: false, scenes: [] });
const scene = world.makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [0, 0, 50, 50], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateWall", { documentName: "Wall", id: "wall-1", parent: scene });
await world.runTimers();
assert.deepEqual(world.wallPushes(), []);
assert.ok(!world.requests.some((request) => request.href.includes("foundry/sync/maps")));
await world.game.settings.set(MODULE_ID, "autoSync", true);
await world.runTimers();
assert.ok(world.requests.some((request) => request.href.includes("foundry/sync/maps")),
"the campaign's maps are asked for again");
});
}
// --- The map viewer: the editor's wiring -------------------------------------------------------
function mapViewerWiringTests() {
const pane = readRepoFile("frontend", "app", "components", "viewer", "map", "MapViewerPane.vue");
test("the viewer bar opens the wall editor", () => {
assert.match(pane, /:aria-pressed="editingWalls\.toString\(\)" @click="toggleWallEditing"/);
assert.match(pane, /\$t\('campaigns\.map\.walls\.edit'\)/);
});
test("walls are drawn in screen space and only the editor's hit areas catch the mouse", () => {
assert.match(pane, /class="wall-line"[^>]*:class="wallClasses\(wall\)"[^>]*v-bind="wallScreen\(wall\)"/);
assert.match(pane, /\.map-walls\s*\{[^}]*pointer-events:\s*none/);
assert.match(pane, /\.wall-hit\s*\{[^}]*pointer-events:\s*stroke/);
});
test("every wall edit saves the whole set through /map/walls", () => {
assert.match(pane, /updateMap\('\/map\/walls'/);
// A held drag stays local until the pointer lets go, and a wall keeps its _id through saves.
assert.match(pane, /_id: String\(wall\._id\)/);
assert.match(pane, /if \(IsWall\(segment\)\) await saveWalls\(\[\.\.\.walls\.value, segment\]\)/);
});
test("drawn endpoints snap to the grid, like Foundry's wall tool", () => {
assert.match(pane, /import \{ IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall \} from '~\/services\/MapWalls'/);
assert.match(pane, /SnapToGrid\(spot, grid\.value\)/);
});
test("a wall answers the mouse and the keyboard", () => {
assert.match(pane, /@contextmenu\.stop\.prevent="onWallContextMenu\(wall\)"/);
assert.match(pane, /@keydown="onWallKeydown\(\$event, wall\)"/);
assert.match(pane, /Delete.*removeWall|removeWall/);
assert.match(pane, /event\.key !== 'Escape'[\s\S]*drawingWall\.value = null/);
});
}
wallSaveRouteTests();
syncRoutesTests();
mapWallsServiceTests();
foundryModuleWallTests();
mapViewerWiringTests();

View File

@@ -1,157 +0,0 @@
// Tests for the `[[…]]` links a note shows in display mode: the link carries the entry's name, the
// note resolves it against the campaign's lists, and a character or item link previews its sheet
// before opening it. The label lookup is the pure part of `LinkAutocomplete.js`, loaded straight
// from source; the rest is checked by reading the files that wire it together.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
function loadLinkAutocomplete() {
const source = readRepoFile("frontend", "app", "services", "LinkAutocomplete.js");
return new Function(source.replace("export {", "return {"))();
}
const autocomplete = loadLinkAutocomplete();
// --- Finding the entry a written link points at ---
test("a link resolves to the entry whose label it carries", () => {
const targets = [
{ id: "a1", label: "Mira", type: "actor" },
{ id: "i1", label: "Rope of Climbing", type: "item" },
];
assert.deepEqual(autocomplete.FindLinkTarget(targets, "Mira"), targets[0]);
assert.deepEqual(autocomplete.FindLinkTarget(targets, "Rope of Climbing"), targets[1]);
});
test("the lookup forgives case, accents and surrounding spaces", () => {
const targets = [{ id: "a1", label: "Café", type: "actor" }];
assert.equal(autocomplete.FindLinkTarget(targets, "cafe")?.id, "a1");
assert.equal(autocomplete.FindLinkTarget(targets, " CAFÉ ")?.id, "a1");
});
test("a link that no longer matches anything resolves to null", () => {
const targets = [{ id: "a1", label: "Mira", type: "actor" }];
assert.equal(autocomplete.FindLinkTarget(targets, "Mira the Bold"), null);
assert.equal(autocomplete.FindLinkTarget(targets, " "), null);
assert.equal(autocomplete.FindLinkTarget(undefined, "Mira"), null);
});
// --- The rendered link, the resolver and the preview are wired together ---
test("the markdown renders the link's label instead of a placeholder", () => {
const marker = readRepoFile("frontend", "app", "services", "Marker.js");
const link = marker.slice(marker.indexOf("const linkExtension"), marker.indexOf("marker.use"));
assert.match(link, /class="vue-link"/, "the link keeps the class the note binds to");
assert.match(link, /data-href=/, "…and the label it points at");
assert.match(link, /token\.link/, "the label is the link's text");
assert.doesNotMatch(link, />Link</, "the link does not show a generic placeholder");
});
test("the entry lists are shared by the autocomplete, the resolver and the preview", () => {
const targets = readRepoFile("frontend", "app", "services", "LinkTargets.js");
for (const type of ["note", "actor", "item", "map"]) {
assert.ok(targets.includes(`${type}:`), `the link targets do not cover ${type}s`);
}
assert.match(targets, /LoadLinkEntry/, "the preview needs the entry itself, not only its label");
assert.match(targets, /CACHE_TTL/, "the four lists are still cached");
});
test("the note binds its rendered links to the preview and the sheet windows", () => {
const note = readRepoFile("frontend", "app", "components", "viewer", "content", "Note.vue");
assert.match(note, /FindLinkTarget/, "the note resolves the label it renders");
assert.match(note, /LoadLinkEntry/, "…and asks for the entry to preview");
assert.match(note, /classList\.add\('is-resolved'\)/, "resolved links are marked");
assert.match(note, /classList\.add\('is-unresolved'\)/, "a link to a deleted entry is marked too");
assert.match(note, /<LinkPreview/, "the preview card is drawn by the note");
assert.match(note, /'character_sheet'/, "a character link opens its sheet");
assert.match(note, /'item_sheet'/, "an item link opens its sheet");
assert.match(note, /CreateWindow\(windowType/, "…through the same window the sidebar opens");
assert.match(note, /AnchorMap/, "a map link anchors the map like the sidebar does");
});
test("the preview card tells a character from an item", () => {
const preview = readRepoFile("frontend", "app", "components", "viewer", "content", "LinkPreview.vue");
assert.match(preview, /target\.value\.type === 'actor'/);
assert.match(preview, /target\.value\.type === 'item'/);
assert.match(preview, /campaigns\.link-preview\.open-character/);
assert.match(preview, /campaigns\.link-preview\.open-item/);
assert.match(preview, /armorClass/, "the character preview reads the sheet's vitals");
});
// --- `![[…]]`: the entry itself, drawn in the note ---
test("the editor's link menu also completes an embed", () => {
// The trigger starts at the `[[`, so the bang typed before it is kept.
const trigger = autocomplete.FindLinkTrigger("see ![[Mir", 10);
assert.deepEqual(trigger, { start: 5, query: "Mir" });
const result = autocomplete.InsertLinkSuggestion("see ![[Mir", trigger, { label: "Mira" });
assert.equal(result.text, "see ![[Mira]]");
});
test("the bang writes an embed token, and the embed is tried before the plain link", () => {
const marker = readRepoFile("frontend", "app", "services", "Marker.js");
const embed = marker.slice(marker.indexOf("const embedExtension"), marker.indexOf("const linkExtension"));
assert.match(embed, /!\\\[\\\[/, "the token starts with a bang");
assert.match(embed, /class="vue-embed"/, "the note mounts something other than a link");
assert.match(embed, /data-href=/, "…for the label that was written");
assert.doesNotMatch(embed, /class="vue-link"/);
const registration = marker.slice(marker.indexOf("marker.use"));
assert.ok(
registration.indexOf("embedExtension") < registration.indexOf("linkExtension"),
"the embed tokenizer has to run before the link one"
);
});
test("the note mounts an embedded entry the way it mounts a widget", () => {
const note = readRepoFile("frontend", "app", "components", "viewer", "content", "Note.vue");
assert.match(note, /import EmbeddedEntry from '\.\/EmbeddedEntry\.vue'/);
assert.match(note, /querySelectorAll\('\.vue-embed'\)/, "the placeholders Marker left are found");
assert.match(note, /createApp\(EmbeddedEntry,\s*\{\s*href:/, "each one becomes a card of its own");
assert.match(note, /mountEmbeds\(\)/, "…and is mounted with the note");
assert.match(note, /mountedApps\.push\(app\)/, "so it is unmounted when the note re-renders");
});
test("an embed draws the sheet inline and opens the full one", () => {
const embed = readRepoFile("frontend", "app", "components", "viewer", "content", "EmbeddedEntry.vue");
assert.match(embed, /FindLinkTarget/, "the label is resolved exactly like a link");
assert.match(embed, /LoadLinkEntry/, "…and its entry read from the campaign lists");
assert.match(embed, /target\.value\?\.type === 'actor'/, "a character gets its sheet");
assert.match(embed, /target\.value\?\.type === 'item'/, "an item gets its description");
assert.match(embed, /armorClass/, "the character card carries the sheet's vitals");
assert.match(embed, /abilityScores/, "…and the ability scores");
assert.match(embed, /entry\.description/, "the item card carries the description");
assert.match(embed, /CreateWindow\(windowType/, "the full sheet opens from the card");
});
test("the preview strings exist in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "campaigns.json"));
const preview = strings["link-preview"];
assert.ok(preview, `${locale} has no link preview strings`);
for (const key of ["open-character", "open-item", "no-description", "not-found", "close"]) {
assert.ok(preview[key], `${locale} has no link-preview.${key}`);
}
}
});

View File

@@ -1,82 +0,0 @@
// A service asking for its sign-up link describes itself in `target`; the backend
// keeps only the short, plain values it can show the user who answers the link.
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const serviceLinks = require("../backend/src/services/service-links");
const ServiceLinkRequest = require("../backend/src/models/ServiceLinkRequest");
test("a link found by its code can be answered and saved", async () => {
const original = ServiceLinkRequest.findOne;
const document = { _id: "link-1", state: "pending", save: async () => {} };
const query = {
select: () => query,
lean: () => Promise.resolve({ _id: "link-1", state: "pending" }),
then: (resolve, reject) => Promise.resolve(document).then(resolve, reject),
};
ServiceLinkRequest.findOne = () => query;
try {
const request = await serviceLinks.findServiceLinkByCode("code-1");
assert.equal(typeof request?.save, "function",
"the complete route saves the answered link, so it cannot be a plain lean object");
} finally {
ServiceLinkRequest.findOne = original;
}
});
test("unlinking a Foundry world forgets it and revokes its link", async () => {
const original = ServiceLinkRequest.updateMany;
const revocations = [];
ServiceLinkRequest.updateMany = async (filter, update) => {
revocations.push({ filter, update });
return { matchedCount: 1 };
};
try {
const campaign = {
_id: "campaign-1",
foundryWorldId: "world-1",
foundryWorldTitle: "Test World",
foundrySystem: "dnd5e",
foundrySyncTokenHash: "hash",
set(key, value) { this[key] = value; },
async save() { campaign.saved = true; },
};
await serviceLinks.unlinkFoundryWorld(campaign);
assert.equal(campaign.saved, true);
assert.equal(campaign.foundryWorldId, undefined);
assert.equal(campaign.foundryWorldTitle, undefined);
assert.equal(campaign.foundrySystem, undefined);
assert.equal(campaign.foundrySyncTokenHash, undefined);
assert.equal(revocations[0].filter.service, "foundry");
assert.equal(revocations[0].filter.campaign, "campaign-1");
assert.equal(revocations[0].update.$set.state, "revoked");
} finally {
ServiceLinkRequest.updateMany = original;
}
});
test("a link request keeps the service metadata short and plain", () => {
const target = serviceLinks.readTarget({
target: {
id: "world-1",
name: "Test World",
user: "Test GM",
meta: {
system: "dnd5e",
url: "https://vtt.test/some/path",
nested: { ignored: true },
long: "x".repeat(500),
},
},
});
assert.equal(target.targetId, "world-1");
assert.equal(target.targetMeta.system, "dnd5e");
assert.equal(target.targetMeta.url, "https://vtt.test", "only the origin of the world URL is kept");
assert.equal(target.targetMeta.nested, undefined, "objects are not copied into the metadata");
assert.equal(target.targetMeta.long.length, 200, "long values are cut to the metadata limit");
});

View File

@@ -1,148 +0,0 @@
// Tests for the note editor's widget autocomplete (type `@` while editing a note and the widgets of
// Marker.js are offered to insert). The rules live in `frontend/app/services/WidgetAutocomplete.js`,
// which imports nothing, so it is loaded straight from source the way the other tests load the
// frontend services; the repository root installs no dependencies, so `new Function` is enough.
//
// The last checks read the editor and the dropdown, because there the wiring itself is what has to
// stay right: the textarea asks the service, the registry comes from Marker.js, and the two strings
// the dropdown shows exist in every locale.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
function loadWidgetAutocomplete() {
const source = readRepoFile("frontend", "app", "services", "WidgetAutocomplete.js");
return new Function(source.replace("export {", "return {"))();
}
const autocomplete = loadWidgetAutocomplete();
// --- Finding the `@name` the caret is in ---
test("typing after an @ opens a trigger with what has been typed so far", () => {
assert.deepEqual(autocomplete.FindWidgetTrigger("hello @ro", 9), { start: 6, query: "ro" });
assert.deepEqual(autocomplete.FindWidgetTrigger("@", 1), { start: 0, query: "" });
assert.deepEqual(autocomplete.FindWidgetTrigger("@roll", 5), { start: 0, query: "roll" });
assert.deepEqual(autocomplete.FindWidgetTrigger("a\n@r", 4), { start: 2, query: "r" });
});
test("the trigger is the token under the caret, not the rest of the note", () => {
// Caret sits after `@ro`, with more text after it: only the token is replaced later.
assert.deepEqual(autocomplete.FindWidgetTrigger("@ro b", 3), { start: 0, query: "ro" });
});
test("an @ inside a word does not open the menu", () => {
// An email address should never pop the widget list open.
assert.equal(autocomplete.FindWidgetTrigger("user@example", 12), null);
assert.equal(autocomplete.FindWidgetTrigger("x@ro", 4), null);
});
test("a caret away from any @ finds no trigger", () => {
assert.equal(autocomplete.FindWidgetTrigger("just some text", 5), null);
assert.equal(autocomplete.FindWidgetTrigger("", 0), null);
});
// --- The widgets offered, from Marker's registry ---
test("every registered widget is offered, once per way of writing it", () => {
const registry = { inline: ["roll"], display: ["roll"] };
assert.deepEqual(autocomplete.BuildWidgetSuggestions(registry), [
{ name: "roll", type: "inline" },
{ name: "roll", type: "display" },
]);
});
test("a registry with no widgets offers nothing", () => {
assert.deepEqual(autocomplete.BuildWidgetSuggestions({}), []);
assert.deepEqual(autocomplete.BuildWidgetSuggestions(undefined), []);
});
test("the suggestions are filtered by the prefix that has been typed", () => {
const suggestions = [
{ name: "roll", type: "inline" },
{ name: "roll", type: "display" },
{ name: "table", type: "display" },
];
assert.equal(autocomplete.FilterWidgetSuggestions(suggestions, "").length, 3);
assert.deepEqual(autocomplete.FilterWidgetSuggestions(suggestions, "ro"), [
{ name: "roll", type: "inline" },
{ name: "roll", type: "display" },
]);
assert.deepEqual(autocomplete.FilterWidgetSuggestions(suggestions, "zz"), []);
});
// --- What is written when a widget is chosen ---
test("choosing an inline widget writes it with the caret between the brackets", () => {
// "hit @ro" (caret at the end) becomes "hit @roll[]" with the caret before "]".
const trigger = autocomplete.FindWidgetTrigger("hit @ro", 7);
const result = autocomplete.InsertWidgetSuggestion("hit @ro", trigger, { name: "roll", type: "inline" });
assert.equal(result.text, "hit @roll[]");
assert.equal(result.caret, 10);
assert.equal(result.text.slice(0, result.caret) + "|" + result.text.slice(result.caret), "hit @roll[|]");
});
test("choosing a block widget writes it with the caret on the blank line", () => {
const trigger = autocomplete.FindWidgetTrigger("@ro", 3);
const result = autocomplete.InsertWidgetSuggestion("@ro", trigger, { name: "roll", type: "display" });
assert.equal(result.text, "@roll\n\n@end");
assert.equal(result.caret, 6);
assert.equal(result.text.slice(0, result.caret) + "|" + result.text.slice(result.caret), "@roll\n|\n@end");
});
test("only the trigger is replaced, the note around it is kept", () => {
const trigger = autocomplete.FindWidgetTrigger("a @ro b", 5);
const result = autocomplete.InsertWidgetSuggestion("a @ro b", trigger, { name: "roll", type: "inline" });
assert.equal(result.text, "a @roll[] b");
});
// --- The editor and the dropdown are wired together ---
function wiringTests() {
const note = readRepoFile("frontend", "app", "components", "viewer", "content", "Note.vue");
const menu = readRepoFile("frontend", "app", "components", "viewer", "content", "SuggestionMenu.vue");
const marker = readRepoFile("frontend", "app", "services", "Marker.js");
const textarea = /<textarea[^>]*class="full-editor"[^>]*>/.exec(note)?.[0];
test("the editing textarea drives the suggestions from its own text and caret", () => {
assert.ok(textarea, "expected the note editor's textarea");
assert.match(textarea, /@input="onEditorInput"/);
assert.match(textarea, /@keydown="onEditorKeydown"/);
assert.match(note, /from '~\/services\/WidgetAutocomplete'/, "the editor reads the autocomplete service");
});
test("the suggestion menu is drawn while editing", () => {
assert.match(note, /<SuggestionMenu[\s\S]*v-if="suggestions\.length"/, "the menu is shown only when there is something to offer");
assert.match(note, /@select="applySuggestion"/, "choosing an entry inserts it");
assert.match(menu, /@mousedown\.prevent="emit\('select', suggestion\)"/, "a click does not blur the textarea before it lands");
});
test("the widgets shown come from Marker's registry, not a second hand-kept list", () => {
assert.match(marker, /const GetWidgetRegistry/, "Marker exposes the widget registry");
assert.match(marker, /export \{ ParseMarkdown, GetWidget, GetWidgetRegistry \}/);
assert.match(note, /BuildWidgetSuggestions\(GetWidgetRegistry\(\)\)/, "the editor builds its menu from the registry");
});
test("the dropdown's two labels exist in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "general.json"));
for (const type of ["inline", "display"]) {
assert.ok(strings.widgets?.[type], `${locale} has no label for a ${type} widget`);
}
}
});
}
wiringTests();