1 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
eead3c9be8 Fix issue #111: Entry sync on foundry keeps creating new journal entries
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 16:57:28 +00:00
54 changed files with 288 additions and 3803 deletions

View File

@@ -116,14 +116,14 @@ 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 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), 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 `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`, prunes), `scene-delete`, `characters`, `items`, `notes` / `map-note`, `status`,
`map` / `map-item`, `delete`. Rules: `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. - **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. - **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. - **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. - **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`). - **Notes reach the world as journal pages, one way** (Syndria98/dragonroll#98): the module reads `GET /sync/notes` and stands every campaign note as a page of one world `JournalEntry` named Dragonroll — 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 reconcile rewrites pages from the notes and drops the page of a deleted note; journal edits never travel back.
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune. - **`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`). - **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. - `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. // for, shown on the left of the inventory row.
icon: { type: String, default: '' } 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: '' }, traits: { type: String, default: '' },
spells: { type: String, default: '' }, spells: { type: String, default: '' },
campaign: { campaign: {

View File

@@ -14,10 +14,9 @@ const NoteSchema = new Schema({
ref: 'Folder' ref: 'Folder'
}, },
color: { type: String }, color: { type: String },
// The journal page this note is written as in the linked Foundry world: a page // The journal page this note is written as in the linked Foundry world: the
// of the journal of this note's folder (root notes: "Dragonroll") whose rows // page of the one "Dragonroll" journal whose rows carry this note's id in
// carry this note's id in their `dragonroll-foundry.noteId` flag (see the // their `dragonroll-foundry.noteId` flag (see the module's notes sync).
// module's notes sync).
foundryPageId: { type: String }, foundryPageId: { type: String },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });

View File

@@ -74,7 +74,7 @@ router.post('/update', async (req, res) => {
try { try {
const { const {
id, name, species, className, subclass, level, abilityScores, armorClass, speed, hitPoints, hitDice, 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; } = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' }); 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 (languages !== undefined) actor.languages = textList(languages);
if (currency !== undefined) actor.currency = currency; if (currency !== undefined) actor.currency = currency;
if (inventory !== undefined) actor.inventory = inventory; if (inventory !== undefined) actor.inventory = inventory;
if (features !== undefined) actor.features = features;
if (traits !== undefined) actor.traits = traits; if (traits !== undefined) actor.traits = traits;
if (spells !== undefined) actor.spells = spells; if (spells !== undefined) actor.spells = spells;
if (image !== undefined) actor.image = String(image); 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 // Every service links to a campaign through the same sign-up link
// (routes/service-link.js); a campaign only drops one of them again. // (routes/service-link.js); a campaign only drops one of them again.
async function unlinkService(campaign, service) { async function unlinkService(campaign, service) {
// A Foundry world can also let the campaign go from the module itself if (service === 'foundry') {
// (routes/foundry-link.js), so both go through the same helper. campaign.foundryWorldId = undefined;
if (service === 'foundry') return serviceLinks.unlinkFoundryWorld(campaign); campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
if (service === 'discord') { campaign.set('foundrySyncTokenHash', undefined);
} else if (service === 'discord') {
// The Discord account the bot answers to stays: the server is simply // The Discord account the bot answers to stays: the server is simply
// left without a campaign until somebody picks one again. // left without a campaign until somebody picks one again.
campaign.discordGuildId = undefined; campaign.discordGuildId = undefined;

View File

@@ -14,7 +14,6 @@ const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-foundry');
const { foundrySceneToMapData } = require('../services/map-foundry'); const { foundrySceneToMapData } = require('../services/map-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons'); 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). // Upper bound for the Foundry names remembered per synced item (see Item model).
const MAX_FOUNDRY_NAMES = 20; const MAX_FOUNDRY_NAMES = 20;
@@ -67,9 +66,6 @@ function resolveWorldAssets(fields, campaign) {
if (Array.isArray(fields.inventory)) { if (Array.isArray(fields.inventory)) {
for (const entry of fields.inventory) entry.icon = worldAssetUrl(entry.icon, worldUrl); 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, replace = false) {
@@ -584,89 +580,24 @@ router.post('/sync/map-item', async (req, res) => {
}); });
// --- Note pages ------------------------------------------------------------ // --- Note pages ------------------------------------------------------------
// The campaign's notes are read where their authors' table sits: each note // The campaign's notes are read where their authors' table sits: every note
// stands as a page of the journal of the folder it lives in, and root notes share // stands as a page of the one journal the world calls "Dragonroll". Notes are
// the journal the world calls "Dragonroll". Notes are written in Dragonroll, so // written in Dragonroll, so this copy runs one way — the module reads the notes
// this copy runs one way — the module reads the notes and rewrites their pages; // and rewrites their pages; nothing of the journal travels back. Its pages keep
// nothing of the journal travels back. Its pages keep the note's id in a // the note's id in a `dragonroll-foundry.noteId` flag, and the note keeps the
// `dragonroll-foundry.noteId` flag, and the note keeps the page's id here, so // page's id here, so either side recognises the pairing again after a restart.
// either side recognises the pairing again after a restart.
const NOTE_FOLDER_SEPARATOR = ' / ';
// 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);
}
// 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) => {
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 })
.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 });
} 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 // 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 // each one as a page. Folders of the notes do not travel — the journal is flat.
// journal the page belongs to; root notes carry an empty path.
router.get('/sync/notes', async (req, res) => { router.get('/sync/notes', async (req, res) => {
try { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const notes = await Note.find({ campaign: campaign._id }) const notes = await Note.find({ campaign: campaign._id })
.select('_id title content foundryPageId date folder') .select('_id title content foundryPageId date')
.sort({ date: -1 }) .sort({ date: -1 })
.lean(); .lean();
const foldersById = await campaignNoteFolders(campaign._id); res.json({ status: 'ok', notes });
res.json({
status: 'ok',
notes: notes.map((note) => ({
...note,
folderPath: noteFolderPath(note.folder, foldersById),
})),
});
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });
@@ -699,25 +630,6 @@ router.post('/sync/map-note', async (req, res) => {
} }
}); });
// 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) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
if (!requestMatchesWorld(campaign, req.body.worldId)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
await serviceLinks.unlinkFoundryWorld(campaign);
res.json({ status: 'ok' });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;
// The writers every Foundry document goes through: the sync pushes above, and the // The writers every Foundry document goes through: the sync pushes above, and the
// force import a campaign asks for from its sidebar (routes/foundry.js). One set of // force import a campaign asks for from its sidebar (routes/foundry.js). One set of

View File

@@ -111,27 +111,23 @@ function foundryCurrency(system) {
return Object.fromEntries(CURRENCIES.map((key) => [key, Math.max(0, numberOr(coins[key], 0))])); 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 // The character's traits as the world writes them: the free-text details field some
// under the `feat` item type, each with its text and picture on the item. They are what // system releases keep, or its trait items, which are how a monster's traits and a
// the sheet's traits tab lists, one row per feature. // character's racial and class features are written. `undefined` says the world holds
function foundryFeatures(items) { // no traits to show.
return items function foundryTraits(source, 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) {
const text = plainText(source.system?.details?.trait); const text = plainText(source.system?.details?.trait);
const campaignTraits = replace ? '' : asText(savedDragonrollFields.traits); if (text) return text;
return text || campaignTraits || undefined; 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): // `replace` is a forced actor sync from the module's context menu (Syndria98/dragonroll#96):
@@ -192,11 +188,7 @@ function foundryActorToCharacter(foundryActor, replace = false) {
icon: asText(item.img).trim() icon: asText(item.img).trim()
})) }))
.filter((item) => item.name), .filter((item) => item.name),
spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n'), 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)
}; };
// What the world says about each of these, when it says anything: leaving a field // What the world says about each of these, when it says anything: leaving a field
@@ -214,8 +206,9 @@ function foundryActorToCharacter(foundryActor, replace = false) {
if (languages) fields.languages = languages; if (languages) fields.languages = languages;
const currency = foundryCurrency(system); const currency = foundryCurrency(system);
if (currency) fields.currency = currency; if (currency) fields.currency = currency;
const worldTraits = foundryTraits(foundryActor, savedDragonrollFields, replace); const worldTraits = foundryTraits(foundryActor, items);
if (worldTraits) fields.traits = worldTraits; const campaignTraits = replace ? '' : asText(savedDragonrollFields.traits);
if (worldTraits || campaignTraits) fields.traits = worldTraits || campaignTraits;
// A replace writes the fields a live edit would leave out when the world says // 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 // nothing, so the campaign's toggles, lists and text for this actor go with it and

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 // 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. // revoking the link works right away — see services/passport.js.
const OBSIDIAN_TOKEN_TTL = '365d'; 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 // 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, // 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) { async function findServiceLinkByCode(code) {
if (!code) return null; if (!code) return null;
// Not `.lean()`: the link answered by /complete is saved back with its new return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean();
// state, and a plain object has no document behind it to save.
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials');
} }
// The credential that belongs to a link is handed over once and then dropped: // 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; 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 // What a campaign has connected to it, newest link first and one row per
// service, so the campaign settings can list its services together. // service, so the campaign settings can list its services together.
async function listLinkedServices(campaignId) { async function listLinkedServices(campaignId) {
@@ -268,6 +250,5 @@ module.exports = {
serviceName, serviceName,
signUpLinkUrl, signUpLinkUrl,
startServiceLink, startServiceLink,
takeServiceLinkCredentials, takeServiceLinkCredentials
unlinkFoundryWorld
}; };

View File

@@ -11,13 +11,7 @@ The Foundry module uses the client-side package API and hooks documented by Foun
## 1. Install the Foundry module ## 1. Install the Foundry module
In Foundry's **Setup → Add-on Modules → Install Module**, paste the manifest URL Copy the contents of this directory into
`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
`{Foundry user data}/Data/modules/dragonroll-foundry/`. Restart Foundry, then enable **Dragonroll `{Foundry user data}/Data/modules/dragonroll-foundry/`. Restart Foundry, then enable **Dragonroll
Foundry API** in the world's module settings. 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 example one pasted while Dragonroll was restarting — retrying it at world startup and once a minute
until the world finishes linking. until the world finishes linking.
For a local backend, use `http://localhost:5000`; the module adds `/api` like it does for any other For a local backend, use `http://localhost:5000`; the module omits `/api` and the backend accepts
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. 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 **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 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, 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. 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 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 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. client and uses the one-time code instead of a Dragonroll login token.
@@ -145,35 +133,16 @@ about it cross over: the scene's **background picture** and the **grid** laid ov
### Notes ### Notes
The campaign's notes read like the campaign's journal in the world (Syndria98/dragonroll#98): each The campaign's notes read like the campaign's journal in the world (Syndria98/dragonroll#98): every
folder stands as a JournalEntry named after its path. Notes in the root of the campaign share the note stands as a page of one JournalEntry named **Dragonroll**. The module creates that journal — or
journal called **Dragonroll**, and notes in a folder called *Sessions* with a subfolder *Arc 1* share adopts one the GM already made under that name, marking it as the notes' journal — and renders each
the journal **Sessions / Arc 1**; a note is always a page of the journal of its folder. The module note's markdown into page HTML with Foundry's own renderer. Notes are written in Dragonroll, so this
creates those journals — or adopts ones the GM already made under the same name, marking them as the copy runs one way: a note made or edited in the campaign rewrites its page on the next reconcile, and
notes' journals — and renders each note's markdown into the page's HTML (headings, lists, quotes, a note deleted there takes its page with it. A page standing under a note's title but carrying no
code and the inline marks), so the page reads in the journal the way the note reads in Dragonroll. A Dragonroll mark is claimed as that note's page, so a lost pairing does not double it. Any other page in
note's dice widgets become buttons in the page too: pressing one rolls the expression with Foundry's that journal — the GM's own — is left alone, and nothing written in the journal travels back. Autosync
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. 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): The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
| Route | Use | | Route | Use |
@@ -185,11 +154,9 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/scene-delete` | A scene was deleted | | `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/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/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` | The campaign's notes, markdown and all, 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 | | `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 | | `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/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted | | `POST /api/foundry/sync/delete` | An actor was deleted |

View File

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

View File

@@ -180,8 +180,6 @@ Hooks.once("init", () => {
onChange: handleAutoSyncChange, onChange: handleAutoSyncChange,
}); });
registerPairingMenu();
const module = game.modules.get(MODULE_ID); const module = game.modules.get(MODULE_ID);
if (!module) { if (!module) {
console.warn(`${MODULE_ID} | Could not register the public API: module was not found.`); console.warn(`${MODULE_ID} | Could not register the public API: module was not found.`);
@@ -198,33 +196,24 @@ function dragonrollEndpoint(path) {
const apiBase = new URL(endpoint); const apiBase = new URL(endpoint);
const basePath = apiBase.pathname.replace(/\/+$/, ""); const basePath = apiBase.pathname.replace(/\/+$/, "");
const isLocalBackend = ["localhost", "127.0.0.1", "[::1]"].includes(apiBase.hostname)
&& apiBase.port === "5000";
const hasApiPath = basePath.endsWith("/api"); const hasApiPath = basePath.endsWith("/api");
apiBase.pathname = `${hasApiPath ? basePath : `${basePath}/api`}/`; apiBase.pathname = `${hasApiPath || isLocalBackend ? basePath : `${basePath}/api`}/`;
apiBase.search = ""; apiBase.search = "";
apiBase.hash = ""; apiBase.hash = "";
return new URL(path.replace(/^\/+/, ""), apiBase); return new URL(path.replace(/^\/+/, ""), apiBase);
} }
// A Dragonroll that is not there, or a URL that points at the web app instead of
// the API, answers with HTML. Say that plainly instead of a JSON parse error.
async function readDragonrollJson(response, url) {
try {
return await response.json();
} catch {
throw new Error(`Dragonroll answered HTTP ${response.status} at ${url} but not with JSON. Check the Dragonroll Endpoint setting.`);
}
}
async function postDragonroll(path, body, token = "") { async function postDragonroll(path, body, token = "") {
const headers = { "Content-Type": "application/json" }; const headers = { "Content-Type": "application/json" };
if (token) headers.Authorization = `Bearer ${token}`; if (token) headers.Authorization = `Bearer ${token}`;
const url = dragonrollEndpoint(path); const response = await fetch(dragonrollEndpoint(path), {
const response = await fetch(url, {
method: "POST", method: "POST",
headers, headers,
body: JSON.stringify(body), body: JSON.stringify(body),
}); });
const result = await readDragonrollJson(response, url); const result = await response.json();
if (!response.ok || result.status !== "ok") { if (!response.ok || result.status !== "ok") {
throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`); throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`);
} }
@@ -232,11 +221,10 @@ async function postDragonroll(path, body, token = "") {
} }
async function getDragonroll(path, token) { async function getDragonroll(path, token) {
const url = dragonrollEndpoint(path); const response = await fetch(dragonrollEndpoint(path), {
const response = await fetch(url, {
headers: { Authorization: `Bearer ${token}` }, headers: { Authorization: `Bearer ${token}` },
}); });
const result = await readDragonrollJson(response, url); const result = await response.json();
if (!response.ok || result.status !== "ok") { if (!response.ok || result.status !== "ok") {
throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`); throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`);
} }
@@ -317,9 +305,6 @@ async function applyDragonrollLink(result) {
setTimeout(initializeCharacterSync, 0); setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setTimeout(initializeSceneSync, 1000); setTimeout(initializeSceneSync, 1000);
// The notes are pulled over on their own change check; get the first one in
// as soon as the world has a token instead of waiting for the next poll.
setTimeout(reconcileDragonrollNotes, 3000);
} else { } else {
// Without a token this client cannot sync, and only a fresh link gives one. // Without a token this client cannot sync, and only a fresh link gives one.
linkProblem = "this client could not save the token it was given"; linkProblem = "this client could not save the token it was given";
@@ -429,135 +414,6 @@ async function refreshPairingStatus() {
await setPairingStatus(pairingStatusText()); await setPairingStatus(pairingStatusText());
} }
// --- Connection actions ----------------------------------------------------
// The module settings open a small window for the two things a GM does about a
// pairing: hand its sign-up link to somebody, and let the campaign go again.
// The sign-up link lives in a client setting, so copying it is how it reaches
// the browser the user will open it in.
async function copyPairingLink() {
if (getSyncToken()) {
ui.notifications?.info("This world is already linked to a Dragonroll campaign; there is no sign-up link to copy.");
return;
}
if (!game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim()) await requestDragonrollLink();
const link = game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim();
if (!link) {
ui.notifications?.warn("Dragonroll does not have a sign-up link for this world right now. Check the Dragonroll Endpoint setting.");
return;
}
try {
await navigator.clipboard.writeText(link);
ui.notifications?.info("Dragonroll sign-up link copied to the clipboard.");
} catch (error) {
// A browser can refuse the clipboard; the link is still the GM's to copy.
console.warn(`${MODULE_ID} | Could not copy the Dragonroll sign-up link.`, error);
ui.notifications?.warn(`Copy the Dragonroll sign-up link yourself: ${link}`);
}
}
// Letting the campaign go from this side: Dragonroll forgets the world and drops
// the token, so this world can pair with a campaign again. An unreachable
// Dragonroll keeps the token — dropping it here would leave the campaign still
// listing a world that can no longer reach it.
async function unlinkDragonrollCampaign() {
if (!game.user?.isGM || !game.world) return;
const token = getSyncToken();
try {
if (token) await postDragonroll("foundry/sync/unlink", { worldId: game.world.id }, token);
} catch (error) {
if (error.message !== "unauthorized") {
console.error(`${MODULE_ID} | Could not unlink this world from Dragonroll.`, error);
ui.notifications?.warn(`Dragonroll could not unlink this world: ${error.message}`);
return;
}
}
await game.settings.set(MODULE_ID, SETTING_SYNC_TOKEN, "");
linkedCampaignName = "";
linkProblem = "";
await setLink("", "");
await setPairingStatus(pairingStatusText());
ui.notifications?.info("This Foundry world is no longer linked to its Dragonroll campaign.");
await requestDragonrollLink();
}
function registerPairingMenu() {
const ApplicationV2 = globalThis.foundry?.applications?.api?.ApplicationV2;
// The module is loaded without Foundry's settings UI in its tests, and no
// Foundry this module runs on lacks ApplicationV2.
if (typeof game.settings.registerMenu !== "function" || !ApplicationV2) return;
class DragonrollPairingMenu extends ApplicationV2 {
static DEFAULT_OPTIONS = {
id: "dragonroll-pairing-menu",
classes: [MODULE_ID],
window: { title: "Dragonroll Connection", icon: "fa-solid fa-link" },
position: { width: 560 },
actions: {
copyLink() {
return copyPairingLink().then(() => this.render());
},
unlink() {
return unlinkDragonrollCampaign().then(() => this.render());
},
},
};
async _renderHTML() {
const link = game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim();
const root = document.createElement("div");
root.className = "dragonroll-pairing-menu";
const status = document.createElement("p");
status.textContent = pairingStatusText();
root.append(status);
if (link) {
const field = document.createElement("input");
field.type = "text";
field.readOnly = true;
field.value = link;
field.addEventListener("focus", () => field.select());
root.append(field);
}
const actions = document.createElement("div");
actions.className = "dragonroll-pairing-actions";
const copy = document.createElement("button");
copy.type = "button";
copy.dataset.action = "copyLink";
copy.innerHTML = '<i class="fa-solid fa-copy"></i> Copy link';
copy.disabled = Boolean(getSyncToken());
const unlink = document.createElement("button");
unlink.type = "button";
unlink.dataset.action = "unlink";
unlink.innerHTML = '<i class="fa-solid fa-link-slash"></i> Unlink campaign';
unlink.disabled = !getSyncToken();
actions.append(copy, unlink);
root.append(actions);
return root;
}
_replaceHTML(result, content) {
content.replaceChildren(result);
}
}
game.settings.registerMenu(MODULE_ID, "pairingMenu", {
name: "Dragonroll Connection",
label: "Copy link / Unlink",
hint: "Copy this world's sign-up link, or unlink the Dragonroll campaign it was paired with.",
icon: "fa-solid fa-link",
type: DragonrollPairingMenu,
restricted: true,
});
}
function scheduleSnapshotSync(delay = 500) { function scheduleSnapshotSync(delay = 500) {
clearTimeout(syncTimeout); clearTimeout(syncTimeout);
syncTimeout = setTimeout(publishSnapshot, delay); syncTimeout = setTimeout(publishSnapshot, delay);
@@ -1614,455 +1470,68 @@ async function initializeSceneSync() {
} }
// --- Note pages ------------------------------------------------------------ // --- Note pages ------------------------------------------------------------
// The campaign's notes read like the campaign's journal in the world: each folder // The campaign's notes read like the campaign's journal in the world: every note
// stands as a JournalEntry named after its path, and every note inside it is one // stands as a page of one JournalEntry named "Dragonroll". Notes are written in
// of that journal's pages. Notes in the root of the campaign share the journal // Dragonroll, so this copy runs one way — the reconcile writes each note into its
// named "Dragonroll", and a note in "Sessions / Arc 1" belongs to the journal // page and drops the page of a note the campaign deleted. Nothing of the journal
// named after that path. Notes are written in Dragonroll, so this copy runs one way — the // is read back. A page the module made carries the `dragonroll-foundry.noteId`
// reconcile writes each note into its page and drops the page of a note the // flag; one without it that stands under a note's title is claimed as that note's
// campaign deleted. Nothing of the journal is read back, and the GM's own pages // page rather than doubled, and any other page is the GM's own and left alone.
// are left alone: only the ones this module made carry the
// `dragonroll-foundry.noteId` flag. Moving a note to another folder moves its page
// to that folder's journal; the journal of a folder whose notes all left goes with
// them when the GM has no pages of their own in it.
//
// The poll asks Dragonroll for a cheap revision first: the notes are only pulled
// over — and the journals only rewritten — when that revision or the pages this
// module wrote have changed since the last reconcile, so an untouched campaign
// costs one hash comparison instead of a page rewrite every few seconds.
const NOTES_JOURNAL_NAME = "Dragonroll"; const NOTES_JOURNAL_NAME = "Dragonroll";
let noteSyncRunning = false; let noteSyncRunning = false;
let noteSyncErrorLogged = false; let noteSyncErrorLogged = false;
// What the last reconcile was based on: the campaign's notes revision, and a summary
// of the pages this module put in the world. Both unchanged means there is nothing to
// do, which is how an idle campaign skips the whole pull-and-render.
let lastNoteRevision = null;
let lastNoteJournalSignature = null;
function dragonrollNoteId(page) { function dragonrollNoteId(page) {
return page.getFlag?.(MODULE_ID, "noteId") || page.flags?.[MODULE_ID]?.noteId || ""; return page.getFlag?.(MODULE_ID, "noteId") || page.flags?.[MODULE_ID]?.noteId || "";
} }
// --- Links and embeds in a note ------------------------------------------- // A note is markdown, a journal page is HTML. Foundry's own renderer keeps the
// Dragonroll writes `[[Name]]` for a link and `![[Name]]` for an embed. Foundry has its own // page readable in the journal and in its styles; where this Foundry does not
// enrichers for both: `@UUID[…]` becomes a content link that opens the document, and `@Embed[…]` // offer one, escaped paragraphs keep the text legible until it does.
// draws that document's sheet in the page. The note only carries names, so the target is looked up
// in the world the same way the campaign lists it: notes first, then characters, items and maps.
function normalizeNoteLabel(value) {
return String(value ?? "")
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.toLowerCase()
.trim();
}
function noteDocumentUuid(document, documentName) {
return document?.uuid || `${document?.documentName || documentName}.${document?.id}`;
}
// A journal page's uuid is the pair of its journal and its own id; tests and older
// Foundry versions do not always carry the getter, so it is rebuilt when missing.
function notePageUuid(journal, page) {
return page?.uuid || `JournalEntry.${journal.id}.JournalEntryPage.${page.id}`;
}
function noteJournalPages() {
const pages = [];
for (const journal of notesJournals()) {
for (const page of journal.pages?.contents || []) pages.push({ journal, page });
}
return pages;
}
function findNoteJournalPage(needle) {
const pages = noteJournalPages();
// Prefer the page the module itself made for a note: a GM page with the same
// name is not the note the campaign is pointing at.
return pages.find(({ page }) => dragonrollNoteId(page) && normalizeNoteLabel(page.name) === needle)
|| pages.find(({ page }) => normalizeNoteLabel(page.name) === needle)
|| null;
}
// The document a written label points at. An embed only makes sense for a character or
// an item, which are the documents Foundry knows how to show inline.
function findNoteTarget(label, { embed = false } = {}) {
const needle = normalizeNoteLabel(label);
if (!needle) return null;
if (!embed) {
const note = findNoteJournalPage(needle);
if (note) return { uuid: notePageUuid(note.journal, note.page), type: "note" };
}
const actor = (game.actors?.contents || []).find((candidate) => normalizeNoteLabel(candidate.name) === needle);
if (actor) return { uuid: noteDocumentUuid(actor, "Actor"), type: "actor" };
const item = (game.items?.contents || []).find((candidate) => normalizeNoteLabel(candidate.name) === needle);
if (item) return { uuid: noteDocumentUuid(item, "Item"), type: "item" };
if (embed) return null;
const scene = (game.scenes?.contents || []).find((candidate) => normalizeNoteLabel(candidate.name) === needle);
if (scene) return { uuid: noteDocumentUuid(scene, "Scene"), type: "map" };
return null;
}
function noteWikiLinkHtml(label) {
const text = String(label ?? "").trim();
const target = findNoteTarget(text);
if (!target) {
return `<span class="dragonroll-note-link is-unresolved">${escapeNoteHtml(text)}</span>`;
}
return `@UUID[${target.uuid}]{${escapeNoteHtml(text)}}`;
}
function noteEmbedHtml(label) {
const text = String(label ?? "").trim();
const target = findNoteTarget(text, { embed: true });
if (!target) {
return `<span class="dragonroll-note-link is-unresolved">${escapeNoteHtml(text)}</span>`;
}
return `@Embed[${target.uuid}]{${escapeNoteHtml(text)}}`;
}
// A note is markdown, a journal page is HTML. Foundry keeps no markdown renderer
// the module can call — the `TextEditor._getMarkdown` this once probed for was
// never real, so every note fell through to escaped paragraphs and a `#` heading
// stayed a `#` heading — so the note's markdown is drawn here and the journal
// styles the page like any other.
function notePageHtml(content) { function notePageHtml(content) {
const markdown = String(content ?? "").replace(/\r\n?/g, "\n"); const markdown = String(content ?? "");
if (!markdown.trim()) return ""; if (!markdown.trim()) return "";
return markdownBlocks(markdown); if (typeof TextEditor !== "undefined" && typeof TextEditor._getMarkdown === "function") {
} const html = TextEditor._getMarkdown(markdown);
if (html) return html;
// Dragonroll's dice widget is a button in the journal too: pressing it rolls the
// expression in Foundry and posts the result to chat. `adv`/`dis` are Dragonroll's
// names for rolling twice and keeping the better/worse die, which Foundry writes as
// `kh1`/`kl1`; everything else in the expression is already Foundry's syntax.
function dragonrollRollFormula(expression) {
return String(expression ?? "")
.trim()
.replace(/(\d*)d(\d+)\s*adv\b/gi, (match, count, sides) => `2d${sides}kh1`)
.replace(/(\d*)d(\d+)\s*dis\b/gi, (match, count, sides) => `2d${sides}kl1`);
}
function noteRollButtonHtml(expression, block = false) {
const label = String(expression ?? "").trim();
const formula = dragonrollRollFormula(label);
const classes = block ? "dragonroll-note-roll dragonroll-note-roll-block" : "dragonroll-note-roll";
return `<button type="button" class="${classes}" data-dragonroll-roll="${escapeNoteHtml(formula)}"`
+ ` title="Roll ${escapeNoteHtml(label)}">`
+ '<i class="fa-solid fa-dice-d20" aria-hidden="true"></i>'
+ `<span>${escapeNoteHtml(label)}</span></button>`;
}
// Every dice button the module draws listens through one delegated handler: the
// journal re-renders its pages, so binding each button would go stale.
function onDragonrollNoteRollClick(event) {
const button = event.target?.closest?.("[data-dragonroll-roll]");
if (!button) return;
event.preventDefault();
return rollDragonrollNote(button);
}
async function rollDragonrollNote(button) {
const formula = button?.dataset?.dragonrollRoll;
if (!formula) return;
try {
const roll = new Roll(formula);
await roll.evaluate();
await roll.toMessage({
speaker: ChatMessage.getSpeaker(),
flavor: `Dragonroll: <strong>${escapeNoteHtml(formula)}</strong>`,
});
} catch (error) {
console.warn(`${MODULE_ID} | Could not roll "${formula}".`, error);
ui.notifications?.warn?.(`Dragonroll: could not roll ${formula}.`);
} }
} return markdown
.split(/\n\s*\n/)
function bindDragonrollNoteRolls() { .map((block) => `<p>${escapeNoteHtml(block.trim()).replace(/\n/g, "<br />")}</p>`)
if (typeof document === "undefined") return; .join("\n");
document.addEventListener("click", onDragonrollNoteRollClick);
}
// The block-level elements a note is written with, line by line. A blank line
// ends a block, anything no block rule claims is a paragraph, and the single
// newlines inside a paragraph become line breaks.
function markdownBlocks(markdown) {
const lines = markdown.split("\n");
const blocks = [];
let index = 0;
while (index < lines.length) {
const line = lines[index];
if (!line.trim()) {
index += 1;
continue;
}
// A dice widget on its own line: `@roll`, the expression, then `@end`. A
// block without its closing marker is left to the paragraph rules below.
if (/^@roll\s*$/.test(line)) {
let closing = index + 1;
while (closing < lines.length && !/^@end\s*$/.test(lines[closing])) closing += 1;
if (closing < lines.length) {
blocks.push(noteRollButtonHtml(lines.slice(index + 1, closing).join("\n"), true));
index = closing + 1;
continue;
}
}
// A fenced code block: everything up to the line that closes the fence is
// kept as written, escaped rather than read as markdown.
const fence = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
if (fence) {
const marker = fence[1][0];
const isClosingFence = (candidate) => {
const trimmed = candidate.trim();
return trimmed.length >= 3 && [...trimmed].every((character) => character === marker);
};
index += 1;
const code = [];
while (index < lines.length && !isClosingFence(lines[index])) {
code.push(lines[index]);
index += 1;
}
index += 1;
const language = fence[2].trim().split(/\s+/)[0].replace(/[^\w+#-]/g, "");
blocks.push(`<pre><code${language ? ` class="language-${language}"` : ""}>${escapeNoteHtml(code.join("\n"))}</code></pre>`);
continue;
}
if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
blocks.push("<hr />");
index += 1;
continue;
}
const heading = line.match(/^(#{1,6})\s+(.*?)\s*#*\s*$/);
if (heading) {
blocks.push(`<h${heading[1].length}>${noteInlineHtml(heading[2])}</h${heading[1].length}>`);
index += 1;
continue;
}
// A line underlined with `=` or `-` is a heading of its own.
const underline = lines[index + 1]?.match(/^\s*(=+|-+)\s*$/);
if (underline) {
const level = underline[1][0] === "=" ? 1 : 2;
blocks.push(`<h${level}>${noteInlineHtml(line.trim())}</h${level}>`);
index += 2;
continue;
}
if (/^\s*>/.test(line)) {
const quote = [];
while (index < lines.length && /^\s*>/.test(lines[index])) {
quote.push(lines[index].replace(/^\s*>\s?/, ""));
index += 1;
}
blocks.push(`<blockquote>${markdownBlocks(quote.join("\n"))}</blockquote>`);
continue;
}
const listItem = line.match(/^\s*([-*+]|\d+[.)])\s+/);
if (listItem) {
const ordered = /^\d/.test(listItem[1]);
const items = [];
while (index < lines.length) {
const item = lines[index].match(/^\s*(?:[-*+]|\d+[.)])\s+(.*)$/);
if (!item) break;
const continuation = [item[1]];
index += 1;
while (index < lines.length && lines[index].trim()
&& !/^\s*(?:[-*+]|\d+[.)])\s+/.test(lines[index])) {
continuation.push(lines[index].trim());
index += 1;
}
items.push(`<li>${noteInlineHtml(continuation.join("\n")).replace(/\n/g, "<br />")}</li>`);
}
const tag = ordered ? "ol" : "ul";
blocks.push(`<${tag}>\n${items.join("\n")}\n</${tag}>`);
continue;
}
const paragraph = [line.trim()];
index += 1;
while (index < lines.length && lines[index].trim()
&& !/^\s*(`{3,}|~{3,})/.test(lines[index])
&& !/^#{1,6}\s+/.test(lines[index])
&& !/^\s*>/.test(lines[index])
&& !/^\s*(?:[-*+]|\d+[.)])\s+/.test(lines[index])
&& !/^\s*([-*_])(\s*\1){2,}\s*$/.test(lines[index])
&& !/^\s*[=-]+\s*$/.test(lines[index])) {
paragraph.push(lines[index].trim());
index += 1;
}
blocks.push(`<p>${noteInlineHtml(paragraph.join("\n")).replace(/\n/g, "<br />")}</p>`);
}
return blocks.join("\n");
}
// The inline marks inside a block: code spans and dice widgets are lifted out
// first so nothing in them is read as a mark, and the rest — images, links,
// strong, emphasis and strikethrough — are plain, non-nesting replacements over
// escaped text.
function noteInlineHtml(text) {
const atoms = [];
const hold = (html) => {
atoms.push(html);
return `\u0000${atoms.length - 1}\u0000`;
};
let html = String(text)
.replace(/`([^`]+)`/g, (match, code) => hold(`<code>${escapeNoteHtml(code)}</code>`))
.replace(/@roll\s*\[([^\]]*)\]/g, (match, expression) => hold(noteRollButtonHtml(expression)))
// The bang has to be read first: `![[Name]]` would otherwise be caught by the
// link rule and drawn as a plain link.
.replace(/!\[\[([^\n]*?)\]\]/g, (match, label) => hold(noteEmbedHtml(label)))
.replace(/\[\[([^\n]*?)\]\]/g, (match, label) => hold(noteWikiLinkHtml(label)));
html = escapeNoteHtml(html);
html = html.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (match, alt, source) =>
`<img src="${source}" alt="${alt}" />`);
html = html.replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (match, label, href) =>
`<a href="${href}">${label}</a>`);
html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
html = html.replace(/(^|[\s(])__([^_]+)__(?=[\s).,!?:;<]|$)/g, "$1<strong>$2</strong>");
html = html.replace(/(^|[^*])\*([^*]+)\*/g, "$1<em>$2</em>");
html = html.replace(/(^|[\s(])_([^_]+)_(?=[\s).,!?:;<]|$)/g, "$1<em>$2</em>");
html = html.replace(/~~([^~]+)~~/g, "<s>$1</s>");
return html.replace(/\u0000(\d+)\u0000/g, (match, position) => atoms[Number(position)]);
} }
function escapeNoteHtml(value) { function escapeNoteHtml(value) {
return String(value) return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;");
} }
function notePageTitle(entry) { function notePageTitle(entry) {
return String(entry.title || "").trim() || "Untitled note"; return String(entry.title || "").trim() || "Untitled note";
} }
// Which folder's journal a note belongs to: the note's folder id, or the empty // The journal this module writes the campaign's notes into: the one it flagged as
// string for the root notes the "Dragonroll" journal holds. // its own, or one the GM already made under that name. An unflagged one is
function noteFolderKey(entry) { // flagged on use, so renaming it afterwards still leaves the notes' home findable.
return entry?.folder ? String(entry.folder) : ""; function notesJournal() {
const journals = game.journals?.contents || [];
return journals.find((journal) => journal.getFlag?.(MODULE_ID, "notesJournal"))
|| journals.find((journal) => journal.name === NOTES_JOURNAL_NAME)
|| null;
} }
// The journal a note belongs to is named after the folder path Dragonroll sends; async function ensureNotesJournal() {
// root notes keep the journal the world calls "Dragonroll". const existing = notesJournal();
function noteJournalName(entry) {
const path = String(entry?.folderPath ?? "").trim();
return path || NOTES_JOURNAL_NAME;
}
function journalFolderKey(journal) {
const folder = journal.getFlag?.(MODULE_ID, "notesFolder");
return folder === undefined || folder === null ? "" : String(folder);
}
function isNotesJournal(journal) {
return Boolean(journal.getFlag?.(MODULE_ID, "notesJournal")
|| journal.getFlag?.(MODULE_ID, "notesFolder"));
}
// Every journal this module writes the campaign's notes into: the ones it flagged
// for a folder or for the root notes, plus any journal holding a page it made (a
// flag can be lost to a hand edit). The world's journals live in `game.journal`
// (singular) — there is no `game.journals`.
function notesJournals() {
return (game.journal?.contents || []).filter((journal) =>
isNotesJournal(journal)
|| journal.name === NOTES_JOURNAL_NAME
|| (journal.pages?.contents || []).some((page) => dragonrollNoteId(page)));
}
// What the module's journals and pages look like right now: the journals' names
// and each module page's id, title and text. A change here means a GM edited or
// removed something, so the reconcile has to run again even though the campaign's
// notes have not moved.
function notesJournalSignature() {
return notesJournals().map((journal) => {
const pages = (journal.pages?.contents || [])
.filter((page) => dragonrollNoteId(page))
.map((page) => `${page.id}\u0000${page.name ?? ""}\u0000${page.text?.content ?? ""}`)
.sort()
.join("\u0001");
return `${journal.id}\u0000${journal.name ?? ""}\u0000${pages}`;
}).sort().join("\u0002");
}
// The page each module page id stands as, across every journal, so a note that
// moved folders can be found in the journal it is leaving before it is written
// into the one it now belongs to.
function notePageLocations() {
const locations = new Map();
for (const journal of notesJournals()) {
for (const page of journal.pages?.contents || []) {
locations.set(String(page.id), { journal, page });
}
}
return locations;
}
// Foundry lets several journals share a name, so a world can end up holding more
// than one journal for the same folder — a GM-made one beside the module's own, or
// two the module made before this check. The reconcile writes into one of them;
// every other one it made for that folder is a duplicate and goes, so the notes
// never split across journals.
async function removeDuplicateNotesJournals(keep, folderKey) {
for (const journal of [...(game.journal?.contents || [])]) {
if (journal === keep) continue;
if (folderKey) {
if (journalFolderKey(journal) === folderKey && isNotesJournal(journal)) await journal.delete();
} else if (!journalFolderKey(journal)
&& (journal.getFlag?.(MODULE_ID, "notesJournal") || journal.name === NOTES_JOURNAL_NAME)) {
await journal.delete();
}
}
}
// The journal a note is written into, made on first use. A journal the GM already
// made under the folder's name is adopted (and flagged), and a folder journal is
// renamed with its folder so the world keeps reading the same path.
async function ensureNotesJournal(entry) {
const folderKey = noteFolderKey(entry);
const name = noteJournalName(entry);
const journals = notesJournals();
const existing = folderKey
? journals.find((journal) => journalFolderKey(journal) === folderKey)
|| journals.find((journal) => !journalFolderKey(journal)
&& !journal.getFlag?.(MODULE_ID, "notesJournal")
&& journal.name === name)
: journals.find((journal) => journal.getFlag?.(MODULE_ID, "notesJournal"))
|| journals.find((journal) => !journalFolderKey(journal) && journal.name === NOTES_JOURNAL_NAME);
if (existing) { if (existing) {
const updates = {}; if (!existing.getFlag?.(MODULE_ID, "notesJournal")) {
if (String(existing.name ?? "") !== name) updates.name = name; await existing.update({ [`flags.${MODULE_ID}.notesJournal`]: true });
if (folderKey) {
if (journalFolderKey(existing) !== folderKey) {
updates[`flags.${MODULE_ID}.notesFolder`] = folderKey;
} }
} else if (!existing.getFlag?.(MODULE_ID, "notesJournal")) {
updates[`flags.${MODULE_ID}.notesJournal`] = true;
}
if (Object.keys(updates).length) await existing.update(updates);
await removeDuplicateNotesJournals(existing, folderKey);
return existing; return existing;
} }
const created = await JournalEntry.create(
const created = await JournalEntry.create({ { name: NOTES_JOURNAL_NAME, flags: { [MODULE_ID]: { notesJournal: true } } },
name, { renderSheet: false },
flags: { [MODULE_ID]: folderKey ? { notesFolder: folderKey } : { notesJournal: true } }, );
}, { renderSheet: false });
return Array.isArray(created) ? created[0] : created; return Array.isArray(created) ? created[0] : created;
} }
@@ -2109,102 +1578,63 @@ async function reconcileDragonrollNotes() {
if (!token || !game.user?.isGM || !game.world || noteSyncRunning || !isAutoSyncEnabled()) return; if (!token || !game.user?.isGM || !game.world || noteSyncRunning || !isAutoSyncEnabled()) return;
noteSyncRunning = true; noteSyncRunning = true;
try { try {
const { revision } = await getDragonroll("foundry/sync/notes/revision", token);
const remoteRevision = String(revision ?? "");
// Both sides are unchanged since the last reconcile: the campaign's notes hash
// the same and the journal still holds what was written to it. Stop before
// pulling every note over and rendering it again.
if (remoteRevision === lastNoteRevision && notesJournalSignature() === lastNoteJournalSignature) return;
const result = await getDragonroll("foundry/sync/notes", token); const result = await getDragonroll("foundry/sync/notes", token);
const remoteNotes = result.notes || []; const remoteNotes = result.notes || [];
// A campaign without notes gets no journal of its own — but ones it once had // A campaign without notes gets no journal of its own — but one it once had
// stay, so the pages of notes it deleted can go with them. // stays, so the pages of notes it deleted can go with them.
if (!remoteNotes.length && !notesJournals().length) { if (!remoteNotes.length && !notesJournal()) return;
lastNoteRevision = remoteRevision; const journal = await ensureNotesJournal();
lastNoteJournalSignature = ""; if (!journal) return;
return;
}
const pageLocations = notePageLocations(); const remoteById = new Map(remoteNotes.map((entry) => [String(entry._id), entry]));
const journalsByFolder = new Map(); const localByRemoteId = new Map((journal.pages?.contents || [])
.map((page) => [String(dragonrollNoteId(page)), page])
.filter(([noteId]) => noteId));
const retainedPageIds = new Set(); const retainedPageIds = new Set();
// Every page that now holds a note, so the notes can be drawn a second time once
// they all exist: a note that links to another note needs that note's page uuid,
// and the page it points at may have been created after it in this loop.
const renderedPages = [];
for (const entry of remoteNotes) { for (const entry of remoteNotes) {
const folderKey = noteFolderKey(entry); let page = entry.foundryPageId ? journal.pages?.get(entry.foundryPageId) : null;
let journal = journalsByFolder.get(folderKey); if (!page) page = localByRemoteId.get(String(entry._id));
if (!journal) {
journal = await ensureNotesJournal(entry);
if (!journal) continue;
journalsByFolder.set(folderKey, journal);
}
// The note's page can be in the journal it now belongs to, or in the one of
// the folder it left: a note moved in Dragonroll takes its page along.
let location = entry.foundryPageId ? pageLocations.get(String(entry.foundryPageId)) : null;
if (!location) {
const page = (journal.pages?.contents || []).find((candidate) =>
String(dragonrollNoteId(candidate)) === String(entry._id));
if (page) location = { journal, page };
}
let page = location?.page ?? null;
if (page && location.journal !== journal) {
await page.delete();
pageLocations.delete(String(page.id));
page = null;
}
if (page) { if (page) {
retainedPageIds.add(page.id); retainedPageIds.add(page.id);
await applyDragonrollNotePage(page, entry); await applyDragonrollNotePage(page, entry);
renderedPages.push({ journal, page, entry }); if (!entry.foundryPageId) await mapDragonrollNote(entry._id, page.id);
if (String(entry.foundryPageId ?? "") !== String(page.id)) { } else {
await mapDragonrollNote(entry._id, page.id); // A page under the note's title that carries no Dragonroll mark — one the
} // module made before the campaign kept its mapping, or one whose flag was
// lost — is claimed as that note's page instead of adding a second page of
// the same name. Like the item sync's same-name adoption, this is what keeps
// a note from being written as a new page on every reconcile.
const sameName = (journal.pages?.contents || []).find((candidate) => (
String(candidate.name ?? "") === notePageTitle(entry)
&& !dragonrollNoteId(candidate)
&& !retainedPageIds.has(candidate.id)
));
if (sameName) {
retainedPageIds.add(sameName.id);
await applyDragonrollNotePage(sameName, entry);
await mapDragonrollNote(entry._id, sameName.id);
} else { } else {
const created = await createDragonrollNotePage(journal, entry); const created = await createDragonrollNotePage(journal, entry);
if (created) { if (created) {
retainedPageIds.add(created.id); retainedPageIds.add(created.id);
pageLocations.set(String(created.id), { journal, page: created }); // The create carries the note's flag, but a world that drops it would leave
renderedPages.push({ journal, page: created, entry }); // the page unclaimed and the next reconcile would make another: mark it
// again the way the rest of the sync marks its documents.
await applyDragonrollNotePage(created, entry);
await mapDragonrollNote(entry._id, created.id); await mapDragonrollNote(entry._id, created.id);
} }
} }
} }
// Now that every page of this pull exists, draw the notes again: only the pages
// whose wiki links just found their target are written a second time.
for (const { page, entry } of renderedPages) {
await applyDragonrollNotePage(page, entry);
} }
// Pages whose note the campaign deleted go with it, and so does a page left in // Pages whose note the campaign deleted go with it. Only pages this module
// a journal the note no longer belongs to. Only pages this module made are its // made are its business: an unflagged page is the GM's own.
// business: an unflagged page is the GM's own. for (const page of journal.pages?.contents || []) {
for (const journal of notesJournals()) {
for (const page of [...(journal.pages?.contents || [])]) {
const noteId = dragonrollNoteId(page); const noteId = dragonrollNoteId(page);
if (!noteId || retainedPageIds.has(page.id)) continue; if (!noteId || retainedPageIds.has(page.id) || remoteById.has(String(noteId))) continue;
await page.delete(); await page.delete();
} }
}
// A folder journal whose notes have all moved or gone goes with them, unless
// the GM keeps pages of their own in it.
for (const journal of notesJournals()) {
const folderKey = journalFolderKey(journal);
if (!folderKey || (journal.pages?.contents || []).length) continue;
if (remoteNotes.some((entry) => noteFolderKey(entry) === folderKey)) continue;
await journal.delete();
}
lastNoteRevision = remoteRevision;
lastNoteJournalSignature = notesJournalSignature();
noteSyncErrorLogged = false; noteSyncErrorLogged = false;
} catch (error) { } catch (error) {
reportNoteSyncError(error); reportNoteSyncError(error);
@@ -2289,7 +1719,6 @@ async function publishHeartbeat() {
} }
Hooks.once("ready", () => { Hooks.once("ready", () => {
bindDragonrollNoteRolls();
advanceDragonrollLink().then(refreshPairingStatus); advanceDragonrollLink().then(refreshPairingStatus);
// While this world has no campaign, its sign-up link is what the GM has to // While this world has no campaign, its sign-up link is what the GM has to
// work with: keep showing it and keep asking whether it has been answered. // work with: keep showing it and keep asking whether it has been answered.
@@ -2306,12 +1735,10 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
// The campaign's notes arrive as pages of the world's Dragonroll journal. The // The campaign's notes arrive as pages of the world's Dragonroll journal on
// recurring check only asks for a cheap revision, so a note written in the app — // the same rhythm: a note written in the app is on the journal within seconds.
// or a journal page a GM changed — is still picked up shortly, but nothing is
// pulled over or rewritten while both sides stay as the last reconcile left them.
setTimeout(reconcileDragonrollNotes, 3000); setTimeout(reconcileDragonrollNotes, 3000);
setInterval(reconcileDragonrollNotes, 15000); setInterval(reconcileDragonrollNotes, 5000);
// The campaign's maps mirror this world's scenes: the whole list goes once the world is // The campaign's maps mirror this world's scenes: the whole list goes once the world is
// loaded, and that push alone tells the campaign which of its synced maps this world has // loaded, and that push alone tells the campaign which of its synced maps this world has
// let go of. // let go of.
@@ -2361,27 +1788,18 @@ Hooks.once("ready", () => {
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context
// menu, replacing whatever the campaign holds for them. This works with autosync on // menu, replacing whatever the campaign holds for them. This works with autosync on
// and off: it is the one push done on purpose. // and off: it is the one push done on purpose.
// Hooks.on("getActorDirectoryEntryContext", (html, options) => {
// Foundry 13 replaced getActorDirectoryEntryContext with getActorContextOptions, if (!game.user?.isGM || !getSyncToken()) return;
// which fires when the directory first renders, so the hook is registered here at
// load time rather than inside "ready". The entry is always offered and hidden with options.push({
// "visible" when it cannot apply, because the hook may only run once. name: "Dragonroll: Force Sync",
Hooks.on("getActorContextOptions", (application, menuItems) => { icon: '<i class="fa-solid fa-rotate"></i>',
menuItems.push({ // Array.from: the selected entries are jQuery in Foundry 12 and a plain
label: "Dragonroll: Force Sync", // array afterwards, and both are array-like.
icon: "fa-solid fa-rotate", callback: (entries) => forceSyncActorsToDragonroll(
visible: () => Boolean(game.user?.isGM && getSyncToken()), Array.from(entries || [])
onClick: (event, target) => { .map((entry) => game.actors?.get(entry.dataset?.actorId))
// One entry is clicked at a time, but several can be selected: take every .filter(Boolean),
// selected actor directory entry, falling back to the one the menu was ),
// opened for.
const clicked = target?.closest?.("[data-entry-id]") ?? target;
const ids = new Set(
[...(application?.element?.querySelectorAll?.("[data-entry-id].selected") ?? [])]
.map((entry) => entry.dataset?.entryId),
);
if (clicked?.dataset?.entryId) ids.add(clicked.dataset.entryId);
forceSyncActorsToDragonroll([...ids].map((id) => game.actors?.get(id)).filter(Boolean));
},
}); });
}); });

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 built output
COPY --from=builder /app/frontend/.output ./.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 Nuxt port
EXPOSE 3000 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> <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 ToastManager from '~/components/managers/ToastManager.vue';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
import { GetWidget, GetWidgetRegistry, ParseMarkdown } from '~/services/Marker'; import { GetWidget, 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 Server from '~/services/Server'; import Server from '~/services/Server';
import { DisplayToast } from '~/services/Toaster'; import { DisplayToast } from '~/services/Toaster';
import { useI18n } from 'vue-i18n'; import { useI18n } from 'vue-i18n';
import TestWidget from '../widgets/TestWidget.vue'; 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'; // import { GetNote, GetContent } from '@/services/Content';
const props = defineProps(['text', 'title', 'noteKey']); const props = defineProps(['text', 'title', 'noteKey']);
@@ -33,228 +24,6 @@ const showClose = ref(false);
let savedState = { text: '', title: '' }; 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() { function markDirty() {
isDirty.value = sourceText.value !== savedState.text || title.value !== savedState.title; 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(){ function update(){
@@ -508,14 +88,11 @@ function update(){
// la reassignacio de displayText (v-html) eliminaria els contenidors i // la reassignacio de displayText (v-html) eliminaria els contenidors i
// desmuntar-les despres fallaria sobre nodes desaccelats. // desmuntar-les despres fallaria sobre nodes desaccelats.
unmountComponents(); unmountComponents();
hideLinkPreview();
displayText.value = compiledMarkdown.value; displayText.value = compiledMarkdown.value;
setTimeout(() => { setTimeout(() => {
setupHeadings(); setupHeadings();
setupCallout() setupCallout()
setupLinks();
mountComponents(); mountComponents();
mountEmbeds();
}, 0); }, 0);
} }
@@ -530,9 +107,6 @@ onMounted(() => {
savedState = { text: props.text, title: props.title }; savedState = { text: props.text, title: props.title };
emitter.on('title-updated', handleTitleUpdate); emitter.on('title-updated', handleTitleUpdate);
// window.addEventListener('keydown', handleKeydown); // 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); setTimeout(() => setupCallout(), 0);
update(); update();
}); });
@@ -546,8 +120,6 @@ function handleTitleUpdate(data) {
onUnmounted(() => { onUnmounted(() => {
emitter.off('title-updated', handleTitleUpdate); emitter.off('title-updated', handleTitleUpdate);
// window.removeEventListener('keydown', handleKeydown); // window.removeEventListener('keydown', handleKeydown);
window.removeEventListener('scroll', hideLinkPreview, true);
hideLinkPreview();
unmountComponents(); unmountComponents();
}); });
@@ -556,8 +128,6 @@ function handleKeydown(e) {
if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'e') { if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'e') {
e.preventDefault(); // prevent browser default behavior e.preventDefault(); // prevent browser default behavior
editingMode.value = !editingMode.value; editingMode.value = !editingMode.value;
closeSuggestions();
hideLinkPreview();
if(!editingMode.value){ if(!editingMode.value){
update(); update();
SaveNote(); // Save when switching to display mode SaveNote(); // Save when switching to display mode
@@ -710,7 +280,7 @@ function renderFoldTree(items, target) {
function handleFoldClick(e) { function handleFoldClick(e) {
// No plegar quan es fa clic en un enllaç o se selecciona text // 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(); const selection = window.getSelection();
if (selection && selection.toString()) return; if (selection && selection.toString()) return;
@@ -755,39 +325,13 @@ function setupHeadings() {
<span>{{ title }}</span> <span>{{ title }}</span>
</div> </div>
<div class="note-content-container"> <div class="note-content-container">
<template v-if="editingMode"> <textarea v-model="sourceText" class="full-editor" v-if="editingMode"></textarea>
<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>
<div v-else class="note-content" ref="noteContent"> <div v-else class="note-content" ref="noteContent">
<h1>{{ title }}</h1> <h1>{{ title }}</h1>
<div ref="renderedContent" v-html="displayText"></div> <div ref="renderedContent" v-html="displayText"></div>
</div> </div>
</div> </div>
<LinkPreview
v-if="linkPreview"
:preview="linkPreview"
@enter="keepLinkPreview"
@leave="scheduleHideLinkPreview"
@close="hideLinkPreview"
@open="openPreviewedEntry"
/>
</div> </div>
</template> </template>
@@ -895,7 +439,6 @@ width: 100%;
.note-content-container { .note-content-container {
width: 100%; width: 100%;
position: relative;
} }
.note-content :deep(img) { .note-content :deep(img) {
@@ -903,29 +446,4 @@ width: 100%;
height: auto; height: auto;
display: block; /* optional: avoids inline spacing issues */ 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> </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

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

View File

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

View File

@@ -1,6 +1,6 @@
<script setup> <script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'; 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 WindowHandle from './partials/WindowHandle.vue';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter'; 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), name: item.name ?? '', quantity: Number(item.quantity ?? 1), weight: Number(item.weight ?? 0),
icon: item.icon ?? '' 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 ?? '', traits: actor?.traits ?? '',
spells: actor?.spells ?? '', spells: actor?.spells ?? '',
image: actor?.image ?? '' image: actor?.image ?? ''
@@ -238,14 +233,6 @@ function removeInventoryItem(index) {
form.value.inventory.splice(index, 1); 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() { async function saveSheet() {
if (!form.value.name.trim() || saving.value) return; if (!form.value.name.trim() || saving.value) return;
saving.value = true; saving.value = true;
@@ -532,20 +519,8 @@ async function saveSheet() {
<main v-show="activeTab === 'traits'" class="sheet-tab-body"> <main v-show="activeTab === 'traits'" class="sheet-tab-body">
<section class="sheet-panel traits-panel"> <section class="sheet-panel traits-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2> <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')" /> <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 class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p>
<p v-else-if="!form.features.length" class="sheet-copy">{{ $t('campaigns.character-sheet.empty-traits') }}</p>
</section> </section>
</main> </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; } .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, 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: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; } textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.traits-panel, .spells-panel { min-height: 175px; } .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 { display: flex; justify-content: space-between; align-items: center; gap: 8px; }
.panel-title-row h2 { flex: 1; } .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; } .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="vert bot">
<div class="button-container"> <div class="button-container">
<button class="btn-primary button-expand sound-click" v-on:click="CreateCampaignWindow" ref="campaignButton">{{ $t("main-menu.create-campaign") }}</button> <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> </div>
</div> </div>
@@ -145,6 +146,24 @@ h2, h3 {
flex-direction: column; 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 { p {
user-select: none; 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 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. 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 ## 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 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 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: Or in a block of its own, between `@roll` and `@end`, when the roll is worth showing on its own line:
```markdown ```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` 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. 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: The expression understands:
| Written | Meaning | | Written | Meaning |

View File

@@ -15,15 +15,9 @@ Character and item sync works without the bridge.
## Installing the module ## Installing the module
Foundry VTT v12 to v14. In Foundry's **Setup → Add-on Modules → Install Module**, paste the Foundry VTT v12 to v14. Copy the `dragonroll-foundry` folder into
manifest URL `https://dragonroll.aranroig.com/foundry/module.json`. Foundry downloads the module `{Foundry user data}/Data/modules/dragonroll-foundry/`, restart Foundry, and enable **Dragonroll
from your Dragonroll server, and the same URL later tells it when an update is available. Foundry API** in the world's module settings.
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.
The module's own settings hold two things you set: the **Dragonroll Endpoint** — the address of your 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 Dragonroll server, `https://dragonroll.aranroig.com` by default — and **Dragonroll Auto-sync**, which
@@ -58,7 +52,7 @@ Worth knowing:
| The folders grouping that item directory | Item folders with the same names and nesting | | 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 | | 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 | | 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 | | A journal called **Dragonroll** — one page per note | Your campaign's notes. They arrive **from** Dragonroll: what you write in the journal does not go back |
The item list is the world's item directory and nothing else. The gear a character carries is that 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 character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
@@ -84,20 +78,12 @@ 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 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. 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 Notes are the exception that runs one way, because notes are written in Dragonroll: every note stands
stands as a journal named after its path. Notes in the root of the campaign share the journal called as a page of a single journal called **Dragonroll**. A note you make or edit in the app appears on that
**Dragonroll**, while notes in a folder called *Sessions* with a subfolder *Arc 1* share the journal journal within a few seconds, and deleting one takes its page with it. A page that stands under a note's
**Sessions / Arc 1**; every note is a page of the journal of its folder. A note's dice widgets are title but carries no Dragonroll mark is claimed as that note's page, so a pairing that was lost does not
buttons there as well: press one in the journal and Foundry rolls it and posts the result to chat, so double it. Any other page — one the GM made in that journal themselves — is left alone, and nothing
advantage and disadvantage roll the way the campaign's notes describe them. The note's `[[links]]` written in the journal travels back to the campaign.
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 ## Auto-sync, and sending one actor on purpose

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

@@ -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 = { const linkExtension = {
name: "link_to", name: "link_to",
level: "inline", level: "inline",
@@ -134,32 +108,16 @@ const linkExtension = {
}, },
renderer(token) { renderer(token) {
// The link shows the entry's name, not a generic "Link", so a note reads as written. The return `<span class="vue-link" data-href="${escapeAttr(token.link)}">Link</span>`;
// 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>`;
}, },
}; };
marker.use({ marker.use({
// The embed comes before the link: at the `!` of `![[…]]` the embed tokenizer is offered first, extensions: [extension, inlineExtension, linkExtension],
// so the same label written with the bang does not fall through to the plain link.
extensions: [extension, inlineExtension, embedExtension, linkExtension],
}); });
function ParseMarkdown(source) { function ParseMarkdown(source) {
return marker.parse(source || ""); return marker.parse(source || "");
} }
// The widgets a note can use, as `{ inline: [...names], display: [...names] }`. The note editor's export { ParseMarkdown, GetWidget };
// `@` 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 };

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'}), close: () => ClearWindow({type: 'character_sheet'}),
movable: true movable: true
}, },
trait_sheet: {
title: 'windows.trait-sheet',
component: () => import('~/components/windows/TraitWindow.vue'),
close: () => ClearWindow({ type: 'trait_sheet' }),
movable: true
},
item_sheet: { item_sheet: {
title: 'windows.item-sheet', title: 'windows.item-sheet',
component: () => import('~/components/windows/ItemSheetWindow.vue'), component: () => import('~/components/windows/ItemSheetWindow.vue'),

View File

@@ -13,6 +13,7 @@
"saved": "S'ha desat la configuració de la campanya.", "saved": "S'ha desat la configuració de la campanya.",
"saving": "Desant...", "saving": "Desant...",
"services": { "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", "not-connected": "No connectat",
"unlink": "Desenllaça", "unlink": "Desenllaça",
"unlinked": "{service} ja no està connectat amb aquesta campanya.", "unlinked": "{service} ja no està connectat amb aquesta campanya.",
@@ -112,13 +113,6 @@
"error": "No s'han pogut canviar les fitxes d'aquest mapa." "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"
},
"character-sheet": { "character-sheet": {
"title": "Fitxa de personatge", "name": "Nom del personatge", "class": "Classe", "subclass": "Subclasse", "unset-class": "Classe sense definir", "title": "Fitxa de personatge", "name": "Nom del personatge", "class": "Classe", "subclass": "Subclasse", "unset-class": "Classe sense definir",
"tabs": { "abilities": "Característiques", "inventory": "Inventari", "traits": "Trets", "spells": "Conjurs" }, "tabs": { "abilities": "Característiques", "inventory": "Inventari", "traits": "Trets", "spells": "Conjurs" },

View File

@@ -3,9 +3,5 @@
"notes": { "notes": {
"saved": "Nota desada", "saved": "Nota desada",
"save-error": "No s'ha pogut desar la nota" "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", "pinned-note": "Nota fixada",
"documentation": "Documentació", "documentation": "Documentació",
"item-sheet": "Objecte", "item-sheet": "Objecte",
"trait-sheet": "Tret",
"icon-source": "Tria una icona", "icon-source": "Tria una icona",
"foundry-icons": "Icones del Foundry" "foundry-icons": "Icones del Foundry"
} }

View File

@@ -17,6 +17,7 @@
"saved": "Campaign settings saved.", "saved": "Campaign settings saved.",
"saving": "Saving...", "saving": "Saving...",
"services": { "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", "not-connected": "Not connected",
"unlink": "Unlink", "unlink": "Unlink",
"unlinked": "{service} is no longer connected to this campaign.", "unlinked": "{service} is no longer connected to this campaign.",
@@ -116,13 +117,6 @@
"error": "Unable to change the tokens of this map." "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"
},
"character-sheet": { "character-sheet": {
"title": "Character Sheet", "name": "Character name", "class": "Class", "subclass": "Subclass", "unset-class": "Class not set", "title": "Character Sheet", "name": "Character name", "class": "Class", "subclass": "Subclass", "unset-class": "Class not set",
"tabs": { "abilities": "Ability Scores", "inventory": "Inventory", "traits": "Traits", "spells": "Spells" }, "tabs": { "abilities": "Ability Scores", "inventory": "Inventory", "traits": "Traits", "spells": "Spells" },

View File

@@ -10,9 +10,5 @@
"notes": { "notes": {
"saved": "Note saved", "saved": "Note saved",
"save-error": "Unable to save the note" "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", "pinned-note": "Pinned note",
"documentation": "Documentation", "documentation": "Documentation",
"item-sheet": "Item", "item-sheet": "Item",
"trait-sheet": "Trait",
"icon-source": "Choose an icon", "icon-source": "Choose an icon",
"foundry-icons": "Foundry icons" "foundry-icons": "Foundry icons"
} }

View File

@@ -13,6 +13,7 @@
"saved": "Se han guardado los ajustes de la campaña.", "saved": "Se han guardado los ajustes de la campaña.",
"saving": "Guardando...", "saving": "Guardando...",
"services": { "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", "not-connected": "Sin conectar",
"unlink": "Desvincular", "unlink": "Desvincular",
"unlinked": "{service} ya no está conectado a esta campaña.", "unlinked": "{service} ya no está conectado a esta campaña.",
@@ -112,13 +113,6 @@
"error": "No se pudieron cambiar las fichas de este mapa." "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"
},
"character-sheet": { "character-sheet": {
"title": "Hoja de personaje", "name": "Nombre del personaje", "class": "Clase", "subclass": "Subclase", "unset-class": "Clase sin definir", "title": "Hoja de personaje", "name": "Nombre del personaje", "class": "Clase", "subclass": "Subclase", "unset-class": "Clase sin definir",
"tabs": { "abilities": "Características", "inventory": "Inventario", "traits": "Rasgos", "spells": "Conjuros" }, "tabs": { "abilities": "Características", "inventory": "Inventario", "traits": "Rasgos", "spells": "Conjuros" },

View File

@@ -3,9 +3,5 @@
"notes": { "notes": {
"saved": "Nota guardada", "saved": "Nota guardada",
"save-error": "No se ha podido guardar la nota" "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", "pinned-note": "Nota fijada",
"documentation": "Documentación", "documentation": "Documentación",
"item-sheet": "Objeto", "item-sheet": "Objeto",
"trait-sheet": "Rasgo",
"icon-source": "Elegir icono", "icon-source": "Elegir icono",
"foundry-icons": "Iconos de Foundry" "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 -------------------------------------------------------- // --- 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." } } }); const fromText = foundryActorToCharacter({ name: "Thalia", system: { details: { trait: "Spellcaster.<br>Light sleeper." } } });
assert.equal(fromText.traits, "Spellcaster.\nLight 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", name: "Thalia",
system: {}, system: {},
items: [ 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: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } },
{ name: "Second Wind", type: "feat", system: { type: { value: "class" }, description: { value: "Regain hit points." } } }, { name: "Brave", type: "feat", system: { featType: ["tr"], description: { value: "Advantage on saves." } } },
{ name: "Alert", type: "feat", system: { type: { value: "feat" }, description: { value: "Never surprised." } } }, { name: "Alert", type: "feat", system: { featType: "feat", description: { value: "Never surprised." } } },
], ],
}); });
assert.deepEqual(fromFeatures.features, [ assert.equal(fromFeatures.traits, "Darkvision\nSee in the dark.\n\nBrave\nAdvantage on saves.");
{ 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");
}); });
test("the world leads the traits tab, and what the campaign wrote fills in when it has none", () => { test("the world leads the traits tab, and what the campaign wrote fills in when it has none", () => {
@@ -415,20 +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"); 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 // 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 // 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 // the world says nothing are written empty instead of kept, and the campaign's own text

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"); "the inventory holds what the character carries, and nothing else");
assert.deepEqual(character.inventory[0], assert.deepEqual(character.inventory[0],
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" }); { name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" });
assert.deepEqual(character.features, assert.equal(character.traits, "Darkvision\nSee in the dark.", "the feat is read as a trait, where the sheet shows it");
[{ name: "Darkvision", description: "See in the dark.", icon: "" }],
"the feat stands as a feature row, where the sheet shows it");
assert.equal(character.spells, "Magic Missile", "and the spell where its tab shows it"); assert.equal(character.spells, "Magic Missile", "and the spell where its tab shows it");
}); });
@@ -148,7 +146,6 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-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/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/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]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -284,7 +284,6 @@ function loadFoundryWriters({ seed = {} } = {}) {
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-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/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/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]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

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,15 +1,14 @@
// Tests for the campaign's notes reaching the Foundry world as journal pages // 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 // (Syndria98/dragonroll#98): every Dragonroll note stands as a page of the one
// its path (root notes share "Dragonroll"), written by the module and kept in step // journal the world calls "Dragonroll", written by the module and kept in step with
// with the campaign. The copy runs one way — notes are written in Dragonroll — so // the campaign. The copy runs one way — notes are written in Dragonroll — so the
// the backend answers with the notes and their folder paths and remembers each // backend answers with the notes and remembers each note's page; the module reads
// note's page; the module reads them, renders the markdown, moves a page when its // them, renders the markdown, and prunes the page of a note the campaign deleted.
// 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 // 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 // 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 // matcher), and the Foundry module is loaded into a `node:vm` context holding
// stubbed Foundry globals (`game.journal` and `JournalEntry` included) with fake // stubbed Foundry globals (`game.journals` and `JournalEntry` included) with fake
// timers, like tests/item-folder-sync.test.js. // timers, like tests/item-folder-sync.test.js.
// //
// Run with `npm test` from the repository root, or `node --test tests/`. // Run with `npm test` from the repository root, or `node --test tests/`.
@@ -133,7 +132,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-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/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/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]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };
@@ -157,30 +155,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
// --- The sync route: the notes it answers and the page ids it keeps --------------- // --- 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 () => { test("the world reads the campaign's notes with their content and page mapping", async () => {
const sync = loadSyncRoute({ const sync = loadSyncRoute({
seed: { seed: {
@@ -199,47 +173,6 @@ test("the world reads the campaign's notes with their content and page mapping",
assert.equal(response.notes[0].foundryPageId, "page-9", "and the note says which page it already stands as"); 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 () => { 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 sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
@@ -305,18 +238,18 @@ function writeFoundryPaths(target, data) {
return target; return target;
} }
function makeWorld() { function makeWorld({ markdown = true, keepCreateFlags = true, failMapNote = false } = {}) {
const state = { const state = {
hooks: new Map(), hooks: new Map(),
registered: new Map(), registered: new Map(),
requests: [], requests: [],
timers: new Map(), timers: new Map(),
intervals: new Map(), intervals: new Map(),
keepCreateFlags,
failMapNote,
// What Dragonroll answers the notes reconcile with. Mapping a page answers // 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. // like the real backend: the note keeps the page id, so later reads carry it.
remoteNotes: [], remoteNotes: [],
rollMessages: [],
clickListeners: [],
nextId: 1, nextId: 1,
}; };
@@ -330,7 +263,6 @@ function makeWorld() {
text: { content: data.text?.content ?? "" }, text: { content: data.text?.content ?? "" },
flags: data.flags ?? {}, flags: data.flags ?? {},
writes: 0, writes: 0,
get uuid() { return `JournalEntry.${journal.id}.JournalEntryPage.${this.id}`; },
getFlag(module, key) { return this.flags?.[module]?.[key]; }, getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(update) { async update(update) {
page.writes += 1; page.writes += 1;
@@ -352,19 +284,16 @@ function makeWorld() {
name: data.name, name: data.name,
documentName: "JournalEntry", documentName: "JournalEntry",
flags: data.flags ?? {}, flags: data.flags ?? {},
get uuid() { return `JournalEntry.${this.id}`; },
getFlag(module, key) { return this.flags?.[module]?.[key]; }, getFlag(module, key) { return this.flags?.[module]?.[key]; },
pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) }, pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) },
async update(update) { return writeFoundryPaths(this, update); }, 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) { async createEmbeddedDocuments(documentName, docs) {
assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages"); assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages");
// Foundry's own page validation refuses a page without a name. // 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"); 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)); // A world that does not keep the flags a create was handed: the page
// exists but carries no mark, which is what a lost pairing looks like.
const created = docs.map((doc) => makePage(this, keepCreateFlags ? doc : { ...doc, flags: {} }));
pages.push(...created); pages.push(...created);
return created; return created;
}, },
@@ -377,26 +306,6 @@ function makeWorld() {
URL, URL,
CONFIG: {}, CONFIG: {},
window: { location: { origin: "http://vtt.test" } }, 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() {} } }, ui: { notifications: { info() {}, warn() {}, error() {} } },
Hooks: { Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); }, once(name, fn) { state.hooks.set(name, [fn]); },
@@ -421,23 +330,11 @@ function makeWorld() {
const body = options.body ? JSON.parse(options.body) : null; const body = options.body ? JSON.parse(options.body) : null;
state.requests.push({ href, method: options.method, body }); state.requests.push({ href, method: options.method, body });
if (href.includes("foundry/sync/map-note")) { if (href.includes("foundry/sync/map-note")) {
if (state.failMapNote) return { ok: false, status: 500, json: async () => ({ status: "error", msg: "errors.internal" }) };
const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId)); const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId));
if (note) note.foundryPageId = body.foundryPageId; if (note) note.foundryPageId = body.foundryPageId;
return { ok: true, status: 200, json: async () => ({ status: "ok", note }) }; 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")) { 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", notes: state.remoteNotes }) };
} }
@@ -453,6 +350,8 @@ function makeWorld() {
}, },
}, },
}; };
if (markdown) sandbox.TextEditor = { _getMarkdown: (md) => `<marked>${md}</marked>` };
sandbox.game = { sandbox.game = {
user: { isGM: true }, user: { isGM: true },
world: { id: "world-1", title: "Test World" }, world: { id: "world-1", title: "Test World" },
@@ -461,7 +360,7 @@ function makeWorld() {
actors: { contents: [], get: () => null }, actors: { contents: [], get: () => null },
items: { contents: [], get: () => null }, items: { contents: [], get: () => null },
folders: { contents: [], get: () => null }, folders: { contents: [], get: () => null },
journal: { contents: journals, get: (id) => journals.find((journal) => journal.id === id) }, journals: { contents: journals, get: (id) => journals.find((journal) => journal.id === id) },
settings: { settings: {
register(module, key, definition) { register(module, key, definition) {
state.registered.set(key, definition); state.registered.set(key, definition);
@@ -492,9 +391,6 @@ function makeWorld() {
}; };
state.mapNoteRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-note")); 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")); 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)); }; const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => { state.fire = async (name, ...args) => {
@@ -516,19 +412,6 @@ function makeWorld() {
for (const interval of [...state.intervals.values()]) await interval.fn(); for (const interval of [...state.intervals.values()]) await interval.fn();
await drain(); 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 () => { state.linkedSetup = async () => {
await state.fire("init"); await state.fire("init");
await state.fire("ready"); await state.fire("ready");
@@ -555,9 +438,9 @@ test("the campaign's notes become pages of one Dragonroll journal", async () =>
const journal = world.journals()[0]; const journal = world.journals()[0];
assert.equal(journal.name, "Dragonroll"); assert.equal(journal.name, "Dragonroll");
assert.deepEqual(journal.pages.contents.map((page) => [page.name, page.text.content]), [ assert.deepEqual(journal.pages.contents.map((page) => [page.name, page.text.content]), [
["Session 1", "<p><strong>The start</strong></p>"], ["Session 1", "<marked>**The start**</marked>"],
["Tavern Brawl", "<p>A rope, a chandelier.</p>"], ["Tavern Brawl", "<marked>A rope, a chandelier.</marked>"],
], "each note is a page, its markdown drawn into the page's HTML"); ], "each note is a page, its markdown rendered by Foundry's own renderer");
assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"], assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"],
"each page keeps the note it stands for"); "each page keeps the note it stands for");
assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [ assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [
@@ -566,66 +449,6 @@ test("the campaign's notes become pages of one Dragonroll journal", async () =>
], "and the campaign remembers each note's page"); ], "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 () => { test("reconciling again does not double the journal or its pages", async () => {
const world = await makeWorld().linkedSetup(); const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()]; world.remoteNotes = [sessionNote(), tavernNote()];
@@ -651,38 +474,6 @@ test("an existing journal named Dragonroll is used, not doubled", async () => {
assert.equal(gmsOwn.getFlag(MODULE_ID, "notesJournal"), true, "and it is marked, so renaming it keeps the notes' home findable"); 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 () => { test("a note edited in Dragonroll rewrites its page", async () => {
const world = await makeWorld().linkedSetup(); const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()]; world.remoteNotes = [sessionNote()];
@@ -695,7 +486,7 @@ test("a note edited in Dragonroll rewrites its page", async () => {
const journal = world.journals()[0]; const journal = world.journals()[0];
assert.equal(journal.pages.contents.length, 1, "the note still stands as the same single page"); 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.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(journal.pages.contents[0].text.content, "<marked>**A different start**</marked>");
assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping"); assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping");
}); });
@@ -725,43 +516,6 @@ test("pages already in step with the campaign are not rewritten", async () => {
assert.equal(page.writes, 0, "a reconcile that changes nothing leaves the page alone"); 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 () => { test("the campaign's page mapping claims a page whose flag was lost", async () => {
const world = await makeWorld().linkedSetup(); const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll"); const journal = world.addJournal("Dragonroll");
@@ -775,8 +529,59 @@ test("the campaign's page mapping claims a page whose flag was lost", async () =
assert.equal(orphan.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked again"); 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 () => { test("a page under the note's title with no mark is claimed, not doubled", async () => {
const world = await makeWorld().linkedSetup(); const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll");
const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } });
// The campaign has no page id for the note, and the page carries no flag: this
// is a page the module made before the pairing was kept, or one whose flag was
// lost. It is claimed instead of a second page being made under the same title.
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.equal(journal.pages.contents.length, 1, "no second page under the note's title");
assert.equal(existing.text.content, "<marked>**The start**</marked>", "the note's text lands on the page the world already had");
assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked as the note's");
assert.deepEqual(world.mapNoteRequests().map((request) => request.body.foundryPageId), [existing.id],
"the campaign is told which page the note now stands as");
await world.runIntervals();
assert.equal(journal.pages.contents.length, 1, "reconciling again does not add another");
});
test("two notes of one title do not share a single page", async () => {
const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll");
const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } });
world.remoteNotes = [sessionNote(), { _id: "note-9", title: "Session 1", content: "second" }];
await world.runIntervals();
assert.equal(journal.pages.contents.length, 2, "the second note gets a page of its own");
assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "the world's page is claimed by the first note");
assert.equal(journal.pages.contents[1].getFlag(MODULE_ID, "noteId"), "note-9");
});
test("a page whose mark and mapping were both lost is claimed again, not doubled", async () => {
// Both ways of recognising the pairing are gone: the create's flag did not stick,
// and the campaign never got to keep the page id. Without claiming the page it
// already made, every reconcile would write another one.
const world = await makeWorld({ keepCreateFlags: false, failMapNote: true }).linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
await world.runIntervals();
await world.runIntervals();
const journal = world.journals()[0];
assert.equal(journal.pages.contents.length, 1, "one note stands as the one page it was given");
assert.equal(journal.pages.contents[0].getFlag(MODULE_ID, "noteId"), "note-1",
"and the page keeps the note it stands for even though the create did not mark it");
});
test("without Foundry's markdown renderer the fallback keeps the text legible", async () => {
const world = await makeWorld({ markdown: false }).linkedSetup();
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }]; world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }];
await world.runIntervals(); await world.runIntervals();
@@ -784,145 +589,7 @@ test("text that is not markdown is escaped, not injected", async () => {
assert.equal( assert.equal(
world.journals()[0].pages.contents[0].text.content, world.journals()[0].pages.contents[0].text.content,
"<p>a &amp; b &lt; c<br />line two</p>\n<p>second para</p>", "<p>a &amp; b &lt; c<br />line two</p>\n<p>second para</p>",
"the raw text is escaped and stays legible", "escaped paragraphs instead of nothing, until this Foundry offers a renderer",
);
});
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"
); );
}); });

View File

@@ -35,15 +35,12 @@ function makeStubWorld({
linkCode = "", linkCode = "",
linkUrl = "", linkUrl = "",
answers = {}, answers = {},
endpoint = "http://backend.test:5000",
} = {}) { } = {}) {
const state = { const state = {
hooks: new Map(), hooks: new Map(),
registered: new Map(), registered: new Map(),
menus: new Map(),
requests: [], requests: [],
notifications: [], notifications: [],
copied: [],
}; };
const settingsStore = { const settingsStore = {
@@ -51,7 +48,7 @@ function makeStubWorld({
syncToken, syncToken,
linkCode, linkCode,
linkUrl, linkUrl,
dragonrollApiUrl: endpoint, dragonrollApiUrl: "http://backend.test:5000",
}; };
const sandbox = { const sandbox = {
@@ -59,10 +56,6 @@ function makeStubWorld({
URL, URL,
CONFIG: {}, CONFIG: {},
window: { location: { origin: "http://vtt.test" } }, 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: { ui: {
notifications: { notifications: {
info: (text) => state.notifications.push(["info", text]), info: (text) => state.notifications.push(["info", text]),
@@ -116,7 +109,6 @@ function makeStubWorld({
state.registered.set(key, definition); state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default; if (!(key in settingsStore)) settingsStore[key] = definition.default;
}, },
registerMenu(module, key, definition) { state.menus.set(key, definition); },
get(module, key) { return settingsStore[key]; }, get(module, key) { return settingsStore[key]; },
async set(module, key, value) { async set(module, key, value) {
settingsStore[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"); 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 () => { test("a world that holds a token neither asks for a link nor waits on one", async () => {
const world = await makeStubWorld({ const world = await makeStubWorld({
answers: { "foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" } }, 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"); 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 () => { test("whatever is typed into the status is replaced by the real one", async () => {
const world = await makeStubWorld({ const world = await makeStubWorld({
answers: { "foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" } }, 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) { 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 = []; const options = [];
await world.fire("getActorContextOptions", application, options); await world.fire("getActorDirectoryEntryContext", null, options);
const entry = options.find((option) => option.label === "Dragonroll: Force Sync"); 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, "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.callback(actorIds.map((actorId) => ({ dataset: { actorId } })));
await entry.onClick(null, entries[0] ?? null);
await world.runTimers(); await world.runTimers();
} }

View File

@@ -145,7 +145,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-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/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/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]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); 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

@@ -125,7 +125,6 @@ function loadSyncRoute({ seed = {}, worldId = "world-1", settings } = {}) {
if (id === "../services/item-foundry") return { foundryItemToItemData: () => null }; 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/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/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]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

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();