18 Commits

Author SHA1 Message Date
fe662bb351 Image support!
Some checks failed
Test / test (push) Failing after 5s
Build and Deploy Nuxt / build (push) Successful in 1m46s
2026-11-20 19:10:28 +01:00
d61659cfdd More things
Some checks failed
Test / test (push) Failing after 5s
Build and Deploy Nuxt / build (push) Successful in 2m3s
2026-11-20 18:59:01 +01:00
b83f64ff9e jdkjskdj
Some checks failed
Build and Deploy Nuxt / build (push) Successful in 1m10s
Test / test (push) Failing after 2s
2026-10-19 19:42:10 +02:00
1c98af69b2 Kjkdjskdjs
Some checks failed
Test / test (push) Failing after 2s
Build and Deploy Nuxt / build (push) Successful in 27s
2026-10-19 19:26:22 +02:00
18d3805b60 kdjskdjsk
Some checks failed
Test / test (push) Failing after 3s
Build and Deploy Nuxt / build (push) Failing after 48s
2026-10-19 19:23:58 +02:00
6854a650fb jkdsjkd
Some checks failed
Test / test (push) Failing after 2s
Build and Deploy Nuxt / build (push) Successful in 53s
2026-10-19 19:13:57 +02:00
1ec29121e1 Deploy deepseek 2
Some checks failed
Test / test (push) Failing after 2s
Build and Deploy Nuxt / build (push) Successful in 1m51s
2026-10-19 19:04:28 +02:00
b5d5e570d5 Merge pull request 'Fix #109: Add map sync' (#110) from ai/issue-109 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m7s
Reviewed-on: #110
2026-10-16 16:15:44 +00:00
Gitea OpenCode Agent
cd1e3cb125 Fix issue #109: Add map sync
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 16:06:21 +00:00
013c3512fe jkdsjkdsj
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 50s
2026-10-16 17:53:15 +02:00
3f2ac16394 Merge pull request 'Fix #98: Sync notes from dragonroll to foundry' (#103) from ai/issue-98 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m6s
Reviewed-on: #103
2026-10-16 14:31:46 +00:00
55fbacbdd7 Merge branch 'master' into ai/issue-98
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 14:31:39 +00:00
5efe43fd99 Merge pull request 'Fix #96: When right clicking actor on foundry, show action to force sync to dragonroll' (#102) from ai/issue-96 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m8s
Reviewed-on: #102
2026-10-16 14:27:22 +00:00
00ac1b16cd Merge branch 'master' into ai/issue-96
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 14:27:14 +00:00
Gitea OpenCode Agent
07dcf08616 Fix issue #98: Sync notes from dragonroll to foundry
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 23:19:43 +00:00
Gitea OpenCode Agent
967c704801 Fix issue #96: When right clicking actor on foundry, show action to force sync to dragonroll
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:53:03 +00:00
c9ee16f2f2 Merge pull request 'Fix #95: Make documentation a resizable window' (#97) from ai/issue-95 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 54s
Reviewed-on: #97
2026-10-15 22:40:25 +00:00
Gitea OpenCode Agent
abcec4d2ff Fix issue #95: Make documentation a resizable window
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:33:31 +00:00
83 changed files with 5185 additions and 1365 deletions

View File

@@ -84,17 +84,19 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings` - `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings`
- `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId` - `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color` - `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`
- `Media` — `name*`, `file*` (filename in `src/uploads`), `mimeType*`, `campaign*`, `folder` (a note folder; null = root), listed in the notes sidebar beside the notes
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color` - `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color`
- `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs) - `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs)
- `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description` - `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
- `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`) - `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`, or a full URL), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`)
- `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it - `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it
**API surface** (all under `/api`, all `{status,msg}`): **API surface** (all under `/api`, all `{status,msg}`):
- `user` — `register`, `verify-setup?code=`, `setup?code=`, `login` (`{usermail,password}`, accepts username or email → `{token}`), `upload-avatar` (multipart `image`, JWT) / `retrieve-avatar?username=`, `has-admin`, `update-settings` / `get-settings`. Files fetched from `/api/public/<filename>`. - `user` — `register`, `verify-setup?code=`, `setup?code=`, `login` (`{usermail,password}`, accepts username or email → `{token}`), `upload-avatar` (multipart `image`, JWT) / `retrieve-avatar?username=`, `has-admin`, `update-settings` / `get-settings`. Files fetched from `/api/public/<filename>`.
- `campaign` — `create`, `update`, `list`, `retrieve/:id`, `services` + `service-unlink` (what is linked to a campaign) - `campaign` — `create`, `update`, `list`, `retrieve/:id`, `services` + `service-unlink` (what is linked to a campaign)
- `note` — `list?campaign=` (root notes + folders with `parentFolder`), `subfolder/list?campaign=&folder=`, `all?campaign=` (titles only, for the map pin picker), `retrieve/:id`, `create`, `update` (partial), `delete` - `note` — `list?campaign=` (root notes + folders with `parentFolder`), `subfolder/list?campaign=&folder=`, `all?campaign=` (titles only, for the map pin picker), `retrieve/:id`, `create`, `update` (partial), `delete` (both list routes also answer with the `media` standing at that level)
- `media` — `upload` (multipart `file`, plus `campaign` and optional `folder`), `update` (`{id, folder}`, moves a row in the note tree), `delete` (drops the row and its uploaded file)
- `folder` — `list`, `create`, `update`, `rename`, `delete` (recursive: inner notes go to `folder: null`, subfolders re-parent then delete) - `folder` — `list`, `create`, `update`, `rename`, `delete` (recursive: inner notes go to `folder: null`, subfolders re-parent then delete)
- `actor` — `list`, `create`, `update` (partial, ownership checked), `upload-image?actor=` (multipart), `delete` - `actor` — `list`, `create`, `update` (partial, ownership checked), `upload-image?actor=` (multipart), `delete`
- `item` — `list`, `create`, `update` (partial), `delete` - `item` — `list`, `create`, `update` (partial), `delete`
@@ -114,13 +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`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules: `item-snapshot`, `item-delete`, `status`, `unlink`, `delete`. Sync runs **one way — Foundry to
Dragonroll — and only characters and items**; nothing is written back into the world. 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, nesting and colours.
- **`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 and 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.
## 5. Frontend ## 5. Frontend
@@ -142,7 +145,10 @@ name is the slug, and the first heading is the title. `services/Docs.js` reads t
(`import.meta.glob(..., {query:'?raw'})`), builds the sidebar and renders a page with marked; (`import.meta.glob(..., {query:'?raw'})`), builds the sidebar and renders a page with marked;
`services/DocsMarkdown.js` holds the heading/slug helpers the sidebar and the anchors share and imports `services/DocsMarkdown.js` holds the heading/slug helpers the sidebar and the anchors share and imports
nothing so `tests/docs.test.js` can load it. A new group's label goes in `docs.json` under nothing so `tests/docs.test.js` can load it. A new group's label goes in `docs.json` under
`groups.<folder>` **in all three locales**. The first page is served at `/docs` itself. `groups.<folder>` **in all three locales**. The first page is served at `/docs` itself, and inside a
campaign the top bar opens the same pages in the `documentation` window
(`components/windows/DocumentationWindow.vue`), which holds the page it shows as its own state instead
of a route so the campaign stays behind it.
Two kinds of screens: **windows** (floating draggable/resizable overlays) and **content** — the Two kinds of screens: **windows** (floating draggable/resizable overlays) and **content** — the
campaign workspace (`TopBar` + `ContentSidebar` + note column + `StatusBar`), turned on when campaign workspace (`TopBar` + `ContentSidebar` + note column + `StatusBar`), turned on when

View File

@@ -84,6 +84,7 @@ app.use(checkAuth);
// ROUTES WITH AUTH // ROUTES WITH AUTH
app.use('/api/campaign', require('./routes/campaign')); app.use('/api/campaign', require('./routes/campaign'));
app.use('/api/note', require('./routes/note')); app.use('/api/note', require('./routes/note'));
app.use('/api/media', require('./routes/media'));
app.use('/api/folder', require('./routes/folder')); app.use('/api/folder', require('./routes/folder'));
app.use('/api/actor', require('./routes/actor')); app.use('/api/actor', require('./routes/actor'));
app.use('/api/item', require('./routes/item')); app.use('/api/item', require('./routes/item'));

View File

@@ -86,6 +86,14 @@ 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

@@ -0,0 +1,23 @@
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// A media file of a campaign's note tree: an image, a sound, a video or a document uploaded to
// src/uploads and listed in the sidebar beside the notes. It holds no content of its own, only the
// name it shows under, the file it points at and the note folder it stands in.
const MediaSchema = new Schema({
name: { type: String, required: true },
file: { type: String, required: true },
mimeType: { type: String, required: true },
campaign: {
type: Schema.Types.ObjectId,
ref: 'Campaign',
required: true
},
folder: {
type: Schema.Types.ObjectId,
ref: 'Folder'
},
date: { type: Date, default: Date.now }
});
module.exports = mongoose.model('Media', MediaSchema);

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, traits, spells, image, folder proficiencies, skills, savingThrows, tools, languages, currency, inventory, features, 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,6 +111,7 @@ 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,12 +8,11 @@ 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) {
if (service === 'foundry') { // A Foundry world can also let the campaign go from the module itself
campaign.foundryWorldId = undefined; // (routes/foundry-link.js), so both go through the same helper.
campaign.foundryWorldTitle = undefined; if (service === 'foundry') return serviceLinks.unlinkFoundryWorld(campaign);
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined); if (service === 'discord') {
} 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

@@ -6,6 +6,7 @@ const Actor = require('../models/Actor');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
const Map = require('../models/Map'); const Map = require('../models/Map');
const Note = require('../models/Note'); const Note = require('../models/Note');
const Media = require('../models/Media');
const Item = require('../models/Item'); const Item = require('../models/Item');
async function userOwnsCampaign(campaignId, userId) { async function userOwnsCampaign(campaignId, userId) {
@@ -99,6 +100,10 @@ router.post('/delete', async (req, res) => {
{ folder: folderId }, { folder: folderId },
{ $set: { folder: null, date: Date.now() } } { $set: { folder: null, date: Date.now() } }
); );
await Media.updateMany(
{ folder: folderId },
{ $set: { folder: null, date: Date.now() } }
);
await Actor.updateMany( await Actor.updateMany(
{ folder: folderId }, { folder: folderId },
{ $set: { folder: null } } { $set: { folder: null } }

View File

@@ -10,6 +10,7 @@ const Folder = require('../models/Folder');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-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;
@@ -62,11 +63,14 @@ 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) { async function saveFoundryActor(campaign, source, fullSync = false, replace = false) {
const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120); const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryActorToCharacter(source || {}); const fields = foundryActorToCharacter(source || {}, replace);
if (!foundryActorId || !fields.name) return null; if (!foundryActorId || !fields.name) return null;
resolveWorldAssets(fields, campaign); resolveWorldAssets(fields, campaign);
@@ -237,9 +241,7 @@ async function syncFoundryItemFolders(campaign, folderSources) {
// The world owns this tree, so unlike an item's fields a rename or a move // The world owns this tree, so unlike an item's fields a rename or a move
// lands whatever kind of push carried it: the whole tree arrives with each. // lands whatever kind of push carried it: the whole tree arrives with each.
folder.name = source.name; folder.name = source.name;
// Its colour is the one part of the tree the campaign colours too: what the // The colour the world shows for the folder arrives here with the tree.
// world shows arrives here, and what the campaign picks travels back to the
// world with the folder list `/sync/items` answers with.
if (source.color !== undefined) folder.color = source.color; if (source.color !== undefined) folder.color = source.color;
const parent = inTree.has(source.parent) ? folders.get(source.parent) : null; const parent = inTree.has(source.parent) ? folders.get(source.parent) : null;
folder.parentFolder = parent ? parent._id : null; folder.parentFolder = parent ? parent._id : null;
@@ -268,7 +270,6 @@ function resolveFoundryItemFolder(source, folders) {
return folders.get(foundryFolderId.trim())?._id || null; return folders.get(foundryFolderId.trim())?._id || null;
} }
// Linking a world to a campaign happens through the sign-up link every service // Linking a world to a campaign happens through the sign-up link every service
// uses (routes/service-link.js); what stays here is the sync that world keeps up // uses (routes/service-link.js); what stays here is the sync that world keeps up
// with the campaign once that link has handed it its token. // with the campaign once that link has handed it its token.
@@ -304,12 +305,16 @@ router.post('/sync/snapshot', async (req, res) => {
} }
const fullSync = req.body.fullSync === true; const fullSync = req.body.fullSync === true;
// A forced actor sync from the module's context menu replaces the campaign's
// row for the actors it sends entirely (Syndria98/dragonroll#96). It stays
// clear of fullSync: it never prunes, unlike a reconnect's full snapshot.
const replace = req.body.replace === true;
// A module that knows nothing about item folders sends neither the tree // A module that knows nothing about item folders sends neither the tree
// nor the folder of an item, and then nothing here touches the folders. // nor the folder of an item, and then nothing here touches the folders.
const folderSources = Array.isArray(req.body.folders) ? req.body.folders : null; const folderSources = Array.isArray(req.body.folders) ? req.body.folders : null;
const actors = []; const actors = [];
for (const source of actorSources || []) { for (const source of actorSources || []) {
const mapping = await saveFoundryActor(campaign, source, fullSync); const mapping = await saveFoundryActor(campaign, source, fullSync, replace);
if (mapping) actors.push(mapping); if (mapping) actors.push(mapping);
} }
const itemFolders = folderSources ? await syncFoundryItemFolders(campaign, folderSources) : null; const itemFolders = folderSources ? await syncFoundryItemFolders(campaign, folderSources) : null;
@@ -380,41 +385,6 @@ router.post('/sync/delete', async (req, res) => {
} }
}); });
router.get('/sync/characters', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const actors = await Actor.find({ campaign: campaign._id }).sort({ name: 1 }).lean();
res.json({ status: 'ok', actors });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/sync/map', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { actorId, foundryActorId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !actorId || !foundryActorId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const actor = await Actor.findOne({ _id: actorId, campaign: campaign._id });
if (!actor) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await Actor.findOne({ campaign: campaign._id, foundryActorId, _id: { $ne: actor._id } });
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.actor-already-synced' });
actor.foundryActorId = String(foundryActorId).trim().slice(0, 120);
await actor.save();
res.json({ status: 'ok', actor });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Only world-level Foundry items reach this route: an item dropped by an actor // Only world-level Foundry items reach this route: an item dropped by an actor
// still exists in the world, and its actor snapshot overwrites the inventory. // still exists in the world, and its actor snapshot overwrites the inventory.
router.post('/sync/item-delete', async (req, res) => { router.post('/sync/item-delete', async (req, res) => {
@@ -434,43 +404,19 @@ router.post('/sync/item-delete', async (req, res) => {
} }
}); });
// The item list the world reconciles against, together with the folders its rows are // A world letting its campaign go from the module settings: the campaign forgets
// grouped into — the same shape the campaign's own `/item/list` answers with. The folders // the world and the token this request used stops working, so the world is free
// travel back for their colour: the world owns the tree's name and nesting, while whoever // to pair again — and the campaign's settings stop listing it as connected.
// colours a folder on either side expects to see it coloured on the other. router.post('/sync/unlink', async (req, res) => {
router.get('/sync/items', async (req, res) => {
try { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const items = await Item.find({ campaign: campaign._id }).sort({ name: 1 }).lean(); if (!requestMatchesWorld(campaign, req.body.worldId)) {
const folders = await Folder.find({ campaign: campaign._id, target: 'item' })
.select('_id name color foundryFolderId')
.sort({ name: 1 })
.lean();
res.json({ status: 'ok', items, folders });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/sync/map-item', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { itemId, foundryItemId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !itemId || !foundryItemId) {
return res.json({ status: 'error', msg: 'errors.missing-data' }); return res.json({ status: 'error', msg: 'errors.missing-data' });
} }
const item = await Item.findOne({ _id: itemId, campaign: campaign._id }); await serviceLinks.unlinkFoundryWorld(campaign);
if (!item) return res.json({ status: 'error', msg: 'errors.notfound' }); res.json({ status: 'ok' });
const existing = await Item.findOne({ campaign: campaign._id, foundryItemId, _id: { $ne: item._id } });
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.item-already-synced' });
item.foundryItemId = String(foundryItemId).trim().slice(0, 120);
await item.save();
res.json({ status: 'ok', item });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });

108
backend/src/routes/media.js Normal file
View File

@@ -0,0 +1,108 @@
const express = require('express');
const path = require('path');
const fs = require('fs');
const router = express.Router();
const Campaign = require('../models/Campaign');
const Folder = require('../models/Folder');
const Media = require('../models/Media');
const upload = require('../services/storage');
const uploadDir = path.join(__dirname, '..', 'uploads');
async function userOwnsCampaign(campaignId, userId) {
const campaign = await Campaign.findOne({ _id: campaignId, createdBy: userId }).lean();
return Boolean(campaign);
}
// Media stands in the note tree, so its folders are the note folders and nothing else.
async function noteFolderFor(folderId, campaignId) {
if (folderId === null || folderId === undefined || folderId === '') return true;
return Folder.belongsToSection(folderId, campaignId, 'note');
}
// Every media row of a campaign, so a note can link to an upload by name (`[[harbour.png]]`) or
// display it (`![[harbour.png]]`).
router.get('/list', async (req, res) => {
try {
const { campaign } = req.query;
if (!campaign) return res.json({ status: 'error', msg: 'errors.missing-data' });
if (!(await userOwnsCampaign(campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const media = await Media.find({ campaign })
.select('_id name file mimeType date')
.sort({ name: 1 })
.lean();
res.json({ status: 'ok', media });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/upload', upload.single('file'), async (req, res) => {
try {
const { campaign, folder } = req.body;
if (!campaign || !req.file) return res.json({ status: 'error', msg: 'errors.missing-data' });
if (!(await userOwnsCampaign(campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
if (!(await noteFolderFor(folder, campaign))) return res.json({ status: 'error', msg: 'errors.notfound' });
const media = new Media({
name: (req.body.name || req.file.originalname).trim(),
file: req.file.filename,
mimeType: req.file.mimetype,
campaign,
folder: folder || null
});
await media.save();
res.json({ status: 'ok', media });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Moving a media row to another folder of the note tree, the way a note is moved.
router.post('/update', async (req, res) => {
try {
const { id, folder } = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const media = await Media.findById(id);
if (!media) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(media.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
if (!(await noteFolderFor(folder, media.campaign))) return res.json({ status: 'error', msg: 'errors.notfound' });
media.folder = folder || null;
await media.save();
res.json({ status: 'ok', media });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/delete', async (req, res) => {
try {
const { id } = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const media = await Media.findById(id);
if (!media) return res.json({ status: 'error', msg: 'errors.notfound' });
// Unlike a note, a media row can be checked before it is deleted: the file belongs to the
// campaign it is asked from, so this route never drops another campaign's upload.
if (!(await userOwnsCampaign(media.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
await Media.deleteOne({ _id: media._id });
fs.unlink(path.join(uploadDir, media.file), () => {});
res.json({ status: 'ok' });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router;

View File

@@ -3,6 +3,7 @@ const router = express.Router();
const Campaign = require('../models/Campaign'); const Campaign = require('../models/Campaign');
const Note = require('../models/Note'); const Note = require('../models/Note');
const Media = require('../models/Media');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
const Map = require('../models/Map'); const Map = require('../models/Map');
@@ -31,7 +32,13 @@ router.get('/list', async (req, res) => {
.sort({ date: -1 }) .sort({ date: -1 })
.lean(); .lean();
res.json({ status: 'ok', folders, notes: rootNotes }); // The media files standing beside the notes at the root of the tree.
const media = await Media.find({ campaign, folder: null })
.select('_id name file mimeType date')
.sort({ date: -1 })
.lean();
res.json({ status: 'ok', folders, notes: rootNotes, media });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });
@@ -60,7 +67,12 @@ router.get('/subfolder/list', async (req, res) => {
.sort({ date: -1 }) .sort({ date: -1 })
.lean(); .lean();
res.json({ status: 'ok', subfolders, notes }); const media = await Media.find({ campaign, folder })
.select('_id name file mimeType date')
.sort({ date: -1 })
.lean();
res.json({ status: 'ok', subfolders, notes, media });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });

View File

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

View File

@@ -13,6 +13,10 @@ 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,
@@ -161,7 +165,9 @@ async function startServiceLink(service, target) {
async function findServiceLinkByCode(code) { async function findServiceLinkByCode(code) {
if (!code) return null; if (!code) return null;
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean(); // Not `.lean()`: the link answered by /complete is saved back with its new
// state, and a plain object has no document behind it to save.
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials');
} }
// 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:
@@ -207,6 +213,18 @@ 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) {
@@ -250,5 +268,6 @@ module.exports = {
serviceName, serviceName,
signUpLinkUrl, signUpLinkUrl,
startServiceLink, startServiceLink,
takeServiceLinkCredentials takeServiceLinkCredentials,
unlinkFoundryWorld
}; };

View File

@@ -3,7 +3,7 @@
Foundry modules run in the game client, so the module cannot bind an HTTP port on the Foundry host. Foundry modules run in the game client, so the module cannot bind an HTTP port on the Foundry host.
This integration uses a small companion bridge process on that host: This integration uses a small companion bridge process on that host:
1. A linked GM client syncs character Actors and world Items directly with the Dragonroll campaign. 1. A linked GM client syncs character Actors and world Items into the Dragonroll campaign.
2. The module publishes the active world's actor and item snapshot to the optional bridge. 2. The module publishes the active world's actor and item snapshot to the optional bridge.
3. The bridge serves authenticated HTTP read endpoints that Dragonroll proxies under `/api/foundry/*`. 3. The bridge serves authenticated HTTP read endpoints that Dragonroll proxies under `/api/foundry/*`.
@@ -11,7 +11,13 @@ The Foundry module uses the client-side package API and hooks documented by Foun
## 1. Install the Foundry module ## 1. Install the Foundry module
Copy the contents of this directory into In Foundry's **Setup → Add-on Modules → Install Module**, paste the manifest URL
`https://dragonroll.aranroig.com/foundry/module.json`. The frontend serves that manifest and the
zip it points to (`/foundry/dragonroll-foundry.zip`), both built from this directory, and the same
manifest URL is what Foundry checks for updates. A self-hosted Dragonroll serves it at
`https://<your-dragonroll-host>/foundry/module.json`.
Alternatively, copy the contents of this directory into
`{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.
@@ -37,9 +43,8 @@ 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 omits `/api` and the backend accepts For a local backend, use `http://localhost:5000`; the module adds `/api` like it does for any other
the local pairing route at its root. Character synchronization works without the optional snapshot 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.
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
@@ -49,6 +54,13 @@ 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.
@@ -56,26 +68,27 @@ client and uses the one-time code instead of a Dragonroll login token.
## Character and item synchronization ## Character and item synchronization
After linking, the GM client imports Foundry character, NPC, and creature Actors into the campaign. After linking, the GM client imports Foundry character, NPC, and creature Actors into the campaign.
Creates, updates, and deletes sync in either direction; Dragonroll changes are applied in Foundry Sync runs one way only — from Foundry to Dragonroll: creates, updates and deletes in the world reach
within about five seconds. The module currently creates Dragonroll characters in D&D 5e Foundry the campaign, and nothing changed in Dragonroll is written back into Foundry. Character sync requires
worlds. After updating an already-linked world to a version with character sync, create a fresh the D&D 5e Foundry system. After updating an already-linked world to a version with character sync,
pairing code and enter it in Foundry once to issue the sync token. create a fresh pairing code and enter it in Foundry once to issue the sync token.
### Auto-sync, and sending one actor on purpose ### Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** in the module settings (on by default) is what keeps the campaign and this **Dragonroll Auto-sync** in the module settings (on by default) is what keeps the campaign and this
world in step: actors and world items the GM creates, updates or deletes are sent to Dragonroll, and world in step: actors and world items the GM creates, updates or deletes are sent to Dragonroll.
both sides reconcile every few seconds. Turn it off to stop synchronizing altogether — nothing is Turn it off to stop synchronizing altogether — nothing is sent to the campaign, so it keeps whatever
sent to the campaign, and Dragonroll stops rewriting those documents in Foundry, so the campaign it already holds. Turn it back on to send the world's current state again; the Foundry edits queued
keeps whatever it already holds. Turn it back on to reconcile both sides again; the Foundry edits while it was off are sent as the world catches up.
queued while it was off are sent as the world catches up.
With autosync off — or any time a single character needs to cross over right now — right-click an With autosync off — or any time a single character needs to cross over right now — right-click an
actor (or several selected ones) in the Foundry actor directory and pick **Dragonroll: Force Sync**. actor (or several selected ones) in the Foundry actor directory and pick **Dragonroll: Force Sync**.
Those actors, together with the gear carried inside them, are pushed to the campaign immediately even Those actors, together with the gear carried inside them, are pushed to the campaign immediately even
when autosync is off. It is an upsert only: it never prunes the campaign's other actors, which a full when autosync is off, **replacing everything that campaign holds for them** (Syndria98/dragonroll#96):
snapshot does and a forced sync never claims to. Actors Dragonroll does not import (anything that is what the campaign had edited on those actors is written over by what the world says. It replaces
not a character, NPC or creature) are refused with a notification. those actors only — it never prunes the campaign's other actors, which a full snapshot does and a
forced sync never claims to. Actors Dragonroll does not import (anything that is not a character, NPC
or creature) are refused with a notification.
The optional read-only snapshot bridge is not affected: it keeps publishing the world snapshot behind The optional read-only snapshot bridge is not affected: it keeps publishing the world snapshot behind
`/api/foundry/*`, which is never written into the campaign. `/api/foundry/*`, which is never written into the campaign.
@@ -93,17 +106,13 @@ else (Syndria98/dragonroll#67):
or one it renamed away from and remembers (`foundryNames`) — instead of doubling it. Spells, classes, or one it renamed away from and remembers (`foundryNames`) — instead of doubling it. Spells, classes,
subclasses, backgrounds, feats and species are not gear and are not imported. subclasses, backgrounds, feats and species are not gear and are not imported.
- Foundry owns the fields it sends (category from the item type, rarity, quantity, weight, weapon - Foundry owns the fields it sends (category from the item type, rarity, quantity, weight, weapon
properties, description). An item made by hand in Dragonroll is created in the world's item properties, description). Nothing is written from Dragonroll into the world's item directory.
directory on the next reconcile, mapped afterwards, and editing it in Dragonroll updates the Foundry
document.
- The folders grouping the world's item directory arrive in the campaign as its own item folders, tree - The folders grouping the world's item directory arrive in the campaign as its own item folders, tree
and nesting included, and the items are filed in them. A folder's **colour** goes the other way too: and nesting included, and the items are filed in them. What the GM colours in Foundry shows on the
what the GM colours in Foundry shows on the campaign's folder, and what the campaign colours lands on campaign's folder.
the world's folder on the next reconcile (the world's document keeps its name and nesting either way).
- A full snapshot keeps Dragonroll edits on reconnect; live Foundry edits overwrite. Item removal is - A full snapshot keeps Dragonroll edits on reconnect; live Foundry edits overwrite. Item removal is
pruned only by a full snapshot, so a live item push never deletes anything: only a full snapshot sees pruned only by a full snapshot, so a live item push never deletes anything: only a full snapshot sees
the whole world directory and can tell which synced rows it has let go of. Deleting a synced item in the whole world directory and can tell which synced rows it has let go of.
Dragonroll removes its Foundry world copy on the next reconcile.
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):
@@ -112,16 +121,12 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/snapshot` | Actors and world items upsert; `fullSync` also prunes | | `POST /api/foundry/sync/snapshot` | Actors and world items upsert; `fullSync` also prunes |
| `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only | | `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only |
| `POST /api/foundry/sync/item-delete` | A world item was deleted | | `POST /api/foundry/sync/item-delete` | A world item was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry |
| `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/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/map` / `map-item` | Store an id mapping after creating a document | | `POST /api/foundry/sync/unlink` | The module unlinks the world; the campaign forgets it and the token is revoked |
| `POST /api/foundry/sync/delete` | An actor was deleted | | `POST /api/foundry/sync/delete` | An actor was deleted |
Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId` Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId`
flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so flag, so the two sides recognise each other on the next push.
the write is not echoed back. A folder colour is written with that folder held in the client's set of
folders being synced, for the same reason.
## 2. Run the bridge on the Foundry host ## 2. Run the bridge on the Foundry host

View File

@@ -2,13 +2,16 @@
"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.4.0", "version": "0.7.0",
"library": true, "library": true,
"compatibility": { "compatibility": {
"minimum": "12", "minimum": "14",
"verified": "14" "verified": "14"
}, },
"esmodules": [ "esmodules": [
"scripts/api.js" "scripts/api.js"
],
"styles": [
"styles/dragonroll.css"
] ]
} }

View File

@@ -34,7 +34,6 @@ let itemSyncErrorLogged = false;
let folderSyncTimeout; let folderSyncTimeout;
let folderSyncRunning = false; let folderSyncRunning = false;
const syncingItemIds = new Set(); const syncingItemIds = new Set();
const syncingFolderIds = new Set();
const queuedItemChanges = new Map(); const queuedItemChanges = new Map();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
@@ -176,6 +175,8 @@ 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.`);
@@ -192,24 +193,33 @@ 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 || isLocalBackend ? basePath : `${basePath}/api`}/`; apiBase.pathname = `${hasApiPath ? 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 response = await fetch(dragonrollEndpoint(path), { const url = dragonrollEndpoint(path);
const response = await fetch(url, {
method: "POST", method: "POST",
headers, headers,
body: JSON.stringify(body), body: JSON.stringify(body),
}); });
const result = await response.json(); const result = await readDragonrollJson(response, url);
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}.`);
} }
@@ -217,10 +227,11 @@ async function postDragonroll(path, body, token = "") {
} }
async function getDragonroll(path, token) { async function getDragonroll(path, token) {
const response = await fetch(dragonrollEndpoint(path), { const url = dragonrollEndpoint(path);
const response = await fetch(url, {
headers: { Authorization: `Bearer ${token}` }, headers: { Authorization: `Bearer ${token}` },
}); });
const result = await response.json(); const result = await readDragonrollJson(response, url);
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}.`);
} }
@@ -299,7 +310,6 @@ async function applyDragonrollLink(result) {
ui.notifications?.info("This Foundry world is now linked to the Dragonroll campaign."); ui.notifications?.info("This Foundry world is now linked to the Dragonroll campaign.");
scheduleSnapshotSync(0); scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0); setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000);
} 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";
@@ -409,6 +419,135 @@ 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);
@@ -430,8 +569,8 @@ function getSyncToken() {
} }
// Autosync is what the module has always done: every Foundry create, update and // Autosync is what the module has always done: every Foundry create, update and
// delete pushes to Dragonroll, and both sides reconcile on a timer. When it is // delete pushes to Dragonroll. When it is off, nothing syncs on its own and only a
// off, nothing syncs on its own and only a forced actor sync reaches Dragonroll. // forced actor sync reaches Dragonroll.
function isAutoSyncEnabled() { function isAutoSyncEnabled() {
return game.settings.get(MODULE_ID, SETTING_AUTO_SYNC) !== false; return game.settings.get(MODULE_ID, SETTING_AUTO_SYNC) !== false;
} }
@@ -445,10 +584,9 @@ function handleAutoSyncChange(value) {
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
// Switching it back on converges both sides again, then the changes queued // Switching it back on sends everything this world holds, then the changes
// while autosync was off are pushed so this world's state wins over them. // queued while autosync was off.
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
@@ -566,7 +704,7 @@ function reportActorSyncError(error) {
console.warn(`${MODULE_ID} | Character sync failed and will retry.`, error); console.warn(`${MODULE_ID} | Character sync failed and will retry.`, error);
} }
async function pushFoundryActors(actors, fullSync = false) { async function pushFoundryActors(actors, fullSync = false, replace = false) {
const token = getSyncToken(); const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || (!actors.length && !fullSync)) return; if (!token || !game.user?.isGM || !game.world || (!actors.length && !fullSync)) return;
if (game.system.id !== "dnd5e") { if (game.system.id !== "dnd5e") {
@@ -585,6 +723,9 @@ async function pushFoundryActors(actors, fullSync = false) {
// The folder tree those world items stand in (see worldItemFolderSnapshots). // The folder tree those world items stand in (see worldItemFolderSnapshots).
folders: worldItemFolderSnapshots(), folders: worldItemFolderSnapshots(),
fullSync, fullSync,
// A forced sync replaces the campaign's row for these actors outright; a live
// change or a full snapshot never sets this, so the campaign keeps its edits.
replace,
}, token); }, token);
for (const mapping of result.actors || []) { for (const mapping of result.actors || []) {
@@ -607,8 +748,9 @@ async function deleteDragonrollActor(foundryActorId) {
} }
// Sending actors on purpose, whether or not autosync is on: this is the push the // Sending actors on purpose, whether or not autosync is on: this is the push the
// GM asks for. It upserts those actors only, so unlike a full snapshot it never // GM asks for. It replaces everything the campaign holds for those actors (Syndria98/
// prunes anything else the campaign holds. // dragonroll#96), but it upserts them only, so unlike a full snapshot it never prunes
// anything else the campaign holds.
async function forceSyncActorsToDragonroll(actors) { async function forceSyncActorsToDragonroll(actors) {
if (!game.user?.isGM || !game.world || !actors.length) return; if (!game.user?.isGM || !game.world || !actors.length) return;
if (!getSyncToken()) { if (!getSyncToken()) {
@@ -624,7 +766,7 @@ async function forceSyncActorsToDragonroll(actors) {
if (!supported.length) return; if (!supported.length) return;
try { try {
await pushFoundryActors(supported); await pushFoundryActors(supported, false, true);
ui.notifications?.info(supported.length === 1 ui.notifications?.info(supported.length === 1
? `${supported[0].name} was sent to the Dragonroll campaign.` ? `${supported[0].name} was sent to the Dragonroll campaign.`
: `${supported.length} actors were sent to the Dragonroll campaign.`); : `${supported.length} actors were sent to the Dragonroll campaign.`);
@@ -664,7 +806,7 @@ async function flushActorChanges() {
// --- World item sync ------------------------------------------------------- // --- World item sync -------------------------------------------------------
// Items embedded in an actor travel with that actor's snapshot; the items below // Items embedded in an actor travel with that actor's snapshot; the items below
// handle the world-level item directory (game.items) in both directions. // send the world-level item directory (game.items) to the campaign.
function itemPropertyLabels(item) { function itemPropertyLabels(item) {
const values = item.system?.properties?.value; const values = item.system?.properties?.value;
@@ -770,34 +912,7 @@ function getWorldItemSnapshots() {
return (game.items?.contents || []).map(serializeFoundryWorldItem).filter(Boolean); return (game.items?.contents || []).map(serializeFoundryWorldItem).filter(Boolean);
} }
// --- Folder colours ---------------------------------------------------------- // --- Item identities ---------------------------------------------------------
// Colouring a folder is the one thing about the tree the campaign gets to do on its
// own: the world owns what the folders are called and how they nest, and Dragonroll
// owns the colour its user picks for one. So the colour travels back with the folder
// list the item reconcile reads, and lands on the world's folder — marked, like every
// Dragonroll write, so the world does not echo it straight back to the campaign.
async function withFolderSyncSuppressed(folder, callback) {
if (!folder?.id) return callback();
syncingFolderIds.add(folder.id);
try {
return await callback();
} finally {
syncingFolderIds.delete(folder.id);
}
}
async function applyDragonrollFolderColors(entries) {
for (const entry of entries || []) {
const folder = entry?.foundryFolderId ? game.folders?.get(entry.foundryFolderId) : null;
// Only the world's item directories: a Dragonroll folder the world has no document
// for is the campaign's business alone, and making one there is not ours to do.
if (!folder || folder.documentName !== "Folder" || !isWorldItemFolder(folder)) continue;
const color = entry.color || null;
if (itemFolderColor(folder) === color) continue;
await withFolderSyncSuppressed(folder, () => folder.update({ color }));
}
}
function dragonrollItemIdOf(item) { function dragonrollItemIdOf(item) {
return item.getFlag?.(MODULE_ID, "itemId") || item.flags?.[MODULE_ID]?.itemId || ""; return item.getFlag?.(MODULE_ID, "itemId") || item.flags?.[MODULE_ID]?.itemId || "";
@@ -918,436 +1033,14 @@ async function flushItemChanges() {
} }
} }
const CATEGORY_TO_FOUNDRY_ITEM_TYPE = {
weapon: "weapon",
armor: "equipment",
shield: "equipment",
consumable: "consumable",
tool: "tool",
"adventuring-gear": "loot",
"magic-item": "loot",
treasure: "loot",
other: "loot",
};
const RARITY_TO_FOUNDRY_VALUE = {
common: "common",
uncommon: "uncommon",
rare: "rare",
"very-rare": "veryRare",
legendary: "legendary",
artifact: "artifact",
};
function makeFoundryItemData(entry) {
const type = CATEGORY_TO_FOUNDRY_ITEM_TYPE[entry.category] || "loot";
const data = {
name: String(entry.name || "").trim(),
type,
img: getDragonrollImageUrl(entry.image) || undefined,
system: {
quantity: Number(entry.quantity) || 1,
weight: Number(entry.weight) || 0,
rarity: RARITY_TO_FOUNDRY_VALUE[entry.rarity] || "common",
description: { value: entry.description || "" },
},
flags: { [MODULE_ID]: { itemId: String(entry._id), syncMutation: true } },
};
if (type === "equipment") data.system.armor = { type: entry.category === "shield" ? "shield" : "medium" };
return data;
}
function foundryItemUpdateData(entry) {
const updates = {
name: String(entry.name || "").trim(),
"system.quantity": Number(entry.quantity) || 1,
"system.weight": Number(entry.weight) || 0,
"system.rarity": RARITY_TO_FOUNDRY_VALUE[entry.rarity] || "common",
"system.description.value": entry.description || "",
};
// An icon the campaign picked in Dragonroll travels back to Foundry; no icon
// there means leave the world's own choice alone, not erase it.
const image = getDragonrollImageUrl(entry.image);
if (image) updates.img = image;
return updates;
}
async function applyDragonrollItem(item, entry) {
const updates = foundryItemUpdateData(entry);
const changed = Object.entries(updates).some(([key, value]) => documentValue(item, key) !== value);
await withItemSyncSuppressed(item, async () => {
if (changed) await item.update(updates);
if (dragonrollItemIdOf(item) !== String(entry._id)) {
await item.update({ [`flags.${MODULE_ID}.itemId`]: String(entry._id) });
}
});
}
async function mapDragonrollItem(itemId, foundryItemId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map-item", {
worldId: game.world.id,
itemId: String(itemId),
foundryItemId: String(foundryItemId),
}, token);
}
async function createFoundryWorldItem(entry) {
const data = makeFoundryItemData(entry);
if (!data.name) return;
const item = await Item.create(data);
if (!item) return;
await withItemSyncSuppressed(item, async () => {
await item.update({ [`flags.${MODULE_ID}.syncMutation`]: false });
});
await mapDragonrollItem(entry._id, item.id);
}
async function reconcileDragonrollItems() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || itemSyncRunning || !isAutoSyncEnabled()) return;
itemSyncRunning = true;
try {
const result = await getDragonroll("foundry/sync/items", token);
// The folder colours are applied first, and whatever system this world runs: a
// colour is the same on every one of them, while writing an item is what needs D&D 5e.
await applyDragonrollFolderColors(result.folders);
if (game.system.id !== "dnd5e") {
throw new Error("Item sync currently requires the D&D 5e Foundry system.");
}
const remoteItems = result.items || [];
const remoteById = new Map(remoteItems.map((entry) => [String(entry._id), entry]));
const localByRemoteId = new Map(game.items.contents
.map((item) => [String(dragonrollItemIdOf(item)), item])
.filter(([itemId]) => itemId));
const retainedFoundryIds = new Set();
for (const entry of remoteItems) {
let item = entry.foundryItemId ? game.items.get(entry.foundryItemId) : null;
if (!item) item = localByRemoteId.get(String(entry._id));
if (item) {
retainedFoundryIds.add(item.id);
await applyDragonrollItem(item, entry);
if (!entry.foundryItemId) await mapDragonrollItem(entry._id, item.id);
} else if (entry.foundryItemId) {
// Imported gear that only exists inside an actor's inventory: its actor
// snapshot owns it, so cloning it into the world would duplicate it.
continue;
} else {
// A Dragonroll item named like an unmapped Foundry item maps to that
// document instead of adding a second copy of the same gear.
const sameName = game.items.contents.find((candidate) => candidate.name === String(entry.name).trim()
&& !dragonrollItemIdOf(candidate));
if (sameName) {
retainedFoundryIds.add(sameName.id);
await mapDragonrollItem(entry._id, sameName.id);
} else {
await createFoundryWorldItem(entry);
}
}
}
for (const item of game.items.contents) {
const itemId = dragonrollItemIdOf(item);
if (!itemId || retainedFoundryIds.has(item.id) || remoteById.has(String(itemId))) continue;
await withItemSyncSuppressed(item, () => item.delete());
}
itemSyncErrorLogged = false;
} catch (error) {
reportItemSyncError(error);
} finally {
itemSyncRunning = false;
}
}
function getDragonrollImageUrl(image) {
if (!image) return "";
if (/^(https?:|data:|\/\/)/i.test(image)) return image;
const endpoint = new URL(game.settings.get(MODULE_ID, SETTING_DRAGONROLL_API_URL));
const basePath = endpoint.pathname.replace(/\/+$/, "");
endpoint.pathname = `${basePath.endsWith("/api") ? basePath : `${basePath}/api`}/public/${encodeURIComponent(image)}`;
endpoint.search = "";
endpoint.hash = "";
return endpoint.toString();
}
function makeFoundryCharacterData(entry) {
const stats = entry.abilityScores || {};
const items = [];
if (entry.className) items.push({ name: entry.className, type: "class", system: { levels: Number(entry.level) || 1 } });
if (entry.subclass) items.push({ name: entry.subclass, type: "subclass" });
if (entry.background) items.push({ name: entry.background, type: "background" });
for (const name of String(entry.spells || "").split("\n").map((value) => value.trim()).filter(Boolean)) {
items.push({ name, type: "spell" });
}
for (const item of entry.inventory || []) {
if (!item.name?.trim()) continue;
items.push({
name: item.name.trim(),
type: "loot",
system: { quantity: Number(item.quantity) || 1, weight: { value: Number(item.weight) || 0 } },
});
}
return {
name: entry.name,
type: entry.type === "character" ? "character" : "npc",
img: getDragonrollImageUrl(entry.image) || undefined,
system: {
// `details.race` and `details.background` are left out on purpose: they reference
// embedded items and are linked once the actor stands with its items made.
details: {
level: Number(entry.level) || 1,
biography: { value: entry.description || "" },
cr: entry.challengeRating || "",
},
abilities: Object.fromEntries(["str", "dex", "con", "int", "wis", "cha"].map((key) => [
key,
{ value: Number(stats[key]) || 10 },
])),
attributes: {
ac: { value: Number(entry.armorClass) || 10 },
movement: { walk: Number(entry.speed) || 30 },
},
},
items,
flags: { [MODULE_ID]: {
actorId: String(entry._id),
actorType: entry.type,
traits: entry.traits || "",
proficiencies: entry.proficiencies || "",
syncMutation: true,
} },
};
}
function documentValue(document, path) {
return path.split(".").reduce((value, key) => value?.[key], document);
}
function characterUpdateData(entry) {
const stats = entry.abilityScores || {};
const updates = {
name: entry.name,
img: getDragonrollImageUrl(entry.image) || "icons/svg/mystery-man.svg",
"system.details.level": Number(entry.level) || 1,
"system.details.biography.value": entry.description || "",
"system.details.cr": entry.challengeRating || "",
[`flags.${MODULE_ID}.traits`]: entry.traits || "",
[`flags.${MODULE_ID}.proficiencies`]: entry.proficiencies || "",
"system.attributes.ac.value": Number(entry.armorClass) || 10,
"system.attributes.movement.walk": Number(entry.speed) || 30,
};
for (const key of ["str", "dex", "con", "int", "wis", "cha"]) {
updates[`system.abilities.${key}.value`] = Number(stats[key]) || 10;
}
return updates;
}
// `system.details.background` and `system.details.race` are LocalDocumentFields in
// D&D 5e: they hold the id of an item embedded in the actor, never its name. A name
// written into one is a reference that resolves to nothing, and adding that item in
// Foundry then fails, so each of these follows the actor's own item for it instead.
const EMBEDDED_DETAILS = [
// Dragonroll owns the background item it lists, so its reference follows it always and
// a background taken off in the campaign leaves no reference behind.
{ field: "background", path: "system.details.background", types: ["background"], clearWhenMissing: true },
// The species item belongs to the world: point at it when it carries the name, and
// leave the reference to the GM when it does not.
{ field: "species", path: "system.details.race", types: ["race", "species"] },
];
function localDocumentId(value) {
// The field resolves to the referenced document when it can and to the stored id
// when the document is gone (its `fallback` option).
if (typeof value === "string") return value;
return value?._id || "";
}
function embeddedDetailReferenceData(actor, entry) {
const updates = {};
for (const detail of EMBEDDED_DETAILS) {
const wanted = String(entry[detail.field] || "").trim();
const item = wanted
? actor.items?.contents?.find((candidate) => detail.types.includes(candidate.type) && candidate.name === wanted)
: null;
const reference = item?.id || "";
if (!reference && !detail.clearWhenMissing) continue;
if (localDocumentId(documentValue(actor, detail.path)) !== reference) updates[detail.path] = reference;
}
return updates;
}
async function reconcileEmbeddedItems(actor, entry) {
const desired = [];
if (entry.className) desired.push({ type: "class", name: entry.className, system: { levels: Number(entry.level) || 1 } });
if (entry.subclass) desired.push({ type: "subclass", name: entry.subclass });
if (entry.background) desired.push({ type: "background", name: entry.background });
for (const name of String(entry.spells || "").split("\n").map((value) => value.trim()).filter(Boolean)) {
desired.push({ type: "spell", name });
}
for (const item of entry.inventory || []) {
if (item.name?.trim()) desired.push({
type: "loot",
name: item.name.trim(),
system: { quantity: Number(item.quantity) || 1, weight: { value: Number(item.weight) || 0 } },
});
}
const retainedIds = new Set();
for (const wanted of desired) {
const existing = actor.items.contents.find((item) => item.name === wanted.name
&& item.type === wanted.type && item.getFlag?.(MODULE_ID, "syncedItem"))
|| actor.items.contents.find((item) => item.name === wanted.name
&& item.getFlag?.(MODULE_ID, "syncedItem") && !WORLD_OWNED_EMBEDDED_TYPES.has(item.type));
// A carried row holding the name of one of the world's own trait or species documents
// — a trait a campaign that synced before #89 still has in its inventory — stands in
// the world as that document: no loot is made after its name, and the document itself
// is let be. Writing it out of the campaign is the campaign's to do, keeping it is the world's.
if (!existing && wanted.type === "loot") {
const worldOwned = actor.items.contents.find((item) => item.name === wanted.name
&& WORLD_OWNED_EMBEDDED_TYPES.has(item.type));
if (worldOwned) {
retainedIds.add(worldOwned.id);
continue;
}
}
if (existing) {
retainedIds.add(existing.id);
const update = { _id: existing.id };
const expected = { name: wanted.name };
if (wanted.system?.levels !== undefined) expected["system.levels"] = wanted.system.levels;
if (wanted.system?.quantity !== undefined) expected["system.quantity"] = wanted.system.quantity;
if (wanted.system?.weight?.value !== undefined) expected["system.weight.value"] = wanted.system.weight.value;
let changed = false;
for (const [key, value] of Object.entries(expected)) {
if (documentValue(existing, key) !== value) {
update[key] = value;
changed = true;
}
}
if (changed) await actor.updateEmbeddedDocuments("Item", [update]);
} else {
const created = await actor.createEmbeddedDocuments("Item", [{
...wanted,
flags: { [MODULE_ID]: { syncedItem: true } },
}]);
for (const item of created) retainedIds.add(item.id);
}
}
const staleItemIds = actor.items.contents
.filter((item) => item.getFlag?.(MODULE_ID, "syncedItem") && !retainedIds.has(item.id)
&& !WORLD_OWNED_EMBEDDED_TYPES.has(item.type))
.map((item) => item.id);
if (staleItemIds.length) await actor.deleteEmbeddedDocuments("Item", staleItemIds);
}
async function applyDragonrollCharacter(actor, entry) {
const updates = characterUpdateData(entry);
const changed = Object.entries(updates).some(([key, value]) => documentValue(actor, key) !== value);
await withActorSyncSuppressed(actor, async () => {
if (changed) await actor.update(updates);
await reconcileEmbeddedItems(actor, entry);
// The item references are written after the reconcile that makes the items they point at.
const references = embeddedDetailReferenceData(actor, entry);
if (Object.keys(references).length) await actor.update(references);
if (dragonrollActorId(actor) !== String(entry._id)
|| actor.getFlag?.(MODULE_ID, "actorType") !== entry.type) {
await actor.update({
[`flags.${MODULE_ID}.actorId`]: String(entry._id),
[`flags.${MODULE_ID}.actorType`]: entry.type,
});
}
});
}
async function mapDragonrollActor(actorId, foundryActorId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map", {
worldId: game.world.id,
actorId: String(actorId),
foundryActorId: String(foundryActorId),
}, token);
}
async function createFoundryCharacter(entry) {
if (game.system.id !== "dnd5e") {
throw new Error("Character sync currently requires the D&D 5e Foundry system.");
}
const actor = await Actor.create(makeFoundryCharacterData(entry), { renderSheet: false });
if (!actor) return;
await withActorSyncSuppressed(actor, async () => {
await actor.update({
// The actor was made with its items, so its background and species references
// can point at them right away.
...embeddedDetailReferenceData(actor, entry),
[`flags.${MODULE_ID}.syncMutation`]: false,
});
});
await mapDragonrollActor(entry._id, actor.id);
}
async function reconcileDragonrollCharacters() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || characterSyncRunning || !isAutoSyncEnabled()) return;
characterSyncRunning = true;
try {
if (game.system.id !== "dnd5e") {
throw new Error("Character sync currently requires the D&D 5e Foundry system.");
}
const result = await getDragonroll("foundry/sync/characters", token);
const remoteActors = result.actors || [];
const remoteById = new Map(remoteActors.map((actor) => [String(actor._id), actor]));
const localByRemoteId = new Map(game.actors.contents
.map((actor) => [String(dragonrollActorId(actor)), actor])
.filter(([actorId]) => actorId));
const retainedFoundryIds = new Set();
for (const entry of remoteActors) {
let actor = entry.foundryActorId ? game.actors.get(entry.foundryActorId) : null;
if (!actor) actor = localByRemoteId.get(String(entry._id));
if (actor) {
retainedFoundryIds.add(actor.id);
await applyDragonrollCharacter(actor, entry);
if (!entry.foundryActorId) await mapDragonrollActor(entry._id, actor.id);
} else {
await createFoundryCharacter(entry);
}
}
for (const actor of game.actors.contents) {
const actorId = dragonrollActorId(actor);
if (!actorId || retainedFoundryIds.has(actor.id) || remoteById.has(String(actorId))) continue;
await withActorSyncSuppressed(actor, () => actor.delete());
}
actorSyncErrorLogged = false;
} catch (error) {
reportActorSyncError(error);
} finally {
characterSyncRunning = false;
}
}
// Both sides converge on a timer that only runs while the world is open, so a
// round that could not reach Dragonroll is asked for again in a while instead of
// leaving the campaign with whatever it happened to receive.
function scheduleDragonrollCharacterSync(delay = 15000) {
clearTimeout(characterSyncRetryTimeout);
characterSyncRetryTimeout = setTimeout(reconcileDragonrollCharacters, delay);
}
async function initializeCharacterSync() { async function initializeCharacterSync() {
if (!getSyncToken() || !game.user?.isGM || !game.world || !isAutoSyncEnabled()) return; if (!getSyncToken() || !game.user?.isGM || !game.world || !isAutoSyncEnabled()) return;
try { try {
await pushFoundryActors(game.actors.contents, true); await pushFoundryActors(game.actors.contents, true);
await reconcileDragonrollCharacters();
} catch (error) { } catch (error) {
reportActorSyncError(error); reportActorSyncError(error);
scheduleDragonrollCharacterSync(15000); clearTimeout(characterSyncRetryTimeout);
characterSyncRetryTimeout = setTimeout(initializeCharacterSync, 15000);
} }
} }
@@ -1443,11 +1136,6 @@ Hooks.once("ready", () => {
scheduleSnapshotSync(0); scheduleSnapshotSync(0);
setInterval(publishHeartbeat, 60000); setInterval(publishHeartbeat, 60000);
setTimeout(initializeCharacterSync, 1000); setTimeout(initializeCharacterSync, 1000);
setInterval(reconcileDragonrollCharacters, 5000);
// Items reconcile after the character snapshot has landed so Dragonroll has
// already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
@@ -1464,9 +1152,7 @@ Hooks.once("ready", () => {
} }
// An item folder the GM made, renamed or nested changes the tree the campaign // An item folder the GM made, renamed or nested changes the tree the campaign
// mirrors; nothing about the items themselves changed, so only the tree goes. // mirrors; nothing about the items themselves changed, so only the tree goes.
// A colour Dragonroll has just written into the folder is not the GM changing it.
if (document.documentName === "Folder") { if (document.documentName === "Folder") {
if (syncingFolderIds.has(document.id)) return;
if (document.type === "Item" && isWorldItemFolder(document)) queueFoundryItemFolders(); if (document.type === "Item" && isWorldItemFolder(document)) queueFoundryItemFolders();
return; return;
} }
@@ -1484,19 +1170,29 @@ 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. This works with autosync on and off: it is the one push done on purpose. // menu, replacing whatever the campaign holds for them. This works with autosync on
Hooks.on("getActorDirectoryEntryContext", (html, options) => { // and off: it is the one push done on purpose.
if (!game.user?.isGM || !getSyncToken()) return; //
// Foundry 13 replaced getActorDirectoryEntryContext with getActorContextOptions,
options.push({ // which fires when the directory first renders, so the hook is registered here at
name: "Dragonroll: Force Sync", // load time rather than inside "ready". The entry is always offered and hidden with
icon: '<i class="fa-solid fa-rotate"></i>', // "visible" when it cannot apply, because the hook may only run once.
// Array.from: the selected entries are jQuery in Foundry 12 and a plain Hooks.on("getActorContextOptions", (application, menuItems) => {
// array afterwards, and both are array-like. menuItems.push({
callback: (entries) => forceSyncActorsToDragonroll( label: "Dragonroll: Force Sync",
Array.from(entries || []) icon: "fa-solid fa-rotate",
.map((entry) => game.actors?.get(entry.dataset?.actorId)) visible: () => Boolean(game.user?.isGM && getSyncToken()),
.filter(Boolean), onClick: (event, target) => {
), // One entry is clicked at a time, but several can be selected: take every
// 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

@@ -0,0 +1,15 @@
/* 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,6 +38,9 @@ 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

@@ -418,3 +418,88 @@ span.artifact {
.fold.is-collapsed > .fold-body { .fold.is-collapsed > .fold-body {
display: none; display: none;
} }
/* El markdown renderitzat de la documentació: tot dins de .docs-markdown, que ve de v-html.
Va aquí perquè la pàgina de /docs (views/DocsView.vue) i la finestra de documentació
(windows/DocumentationWindow.vue) se'l serveixen plegades. */
.docs-markdown h1 {
margin: 0 0 14px 0;
font-family: 'MrEavesRemake', serif;
font-size: 2rem;
font-weight: normal;
line-height: 1.2;
}
.docs-markdown h2 {
margin: 30px 0 10px 0;
padding-bottom: 4px;
border-bottom: 1px solid var(--color-border);
font-family: 'MrEavesRemake', serif;
font-size: 1.35rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown h3 {
margin: 22px 0 8px 0;
font-family: 'MrEavesRemake', serif;
font-size: 1.1rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown p,
.docs-markdown li {
line-height: 1.65;
}
.docs-markdown ul,
.docs-markdown ol {
margin: 10px 0;
padding-left: 1.5em;
}
.docs-markdown a {
color: var(--color-link);
}
.docs-markdown code {
padding: 1px 5px;
border-radius: 4px;
background-color: var(--color-background-light);
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
font-size: 0.9em;
}
.docs-markdown pre {
margin: 14px 0;
padding: 12px 14px;
border: 1px solid var(--color-border);
border-radius: 8px;
background-color: var(--color-background-light);
overflow-x: auto;
}
.docs-markdown pre code {
padding: 0;
background-color: transparent;
}
.docs-markdown table {
margin: 14px 0;
border-collapse: collapse;
width: 100%;
}
.docs-markdown th,
.docs-markdown td {
padding: 7px 10px;
border: 1px solid var(--color-border);
text-align: left;
vertical-align: top;
line-height: 1.5;
}
.docs-markdown th {
background-color: var(--color-background-light);
}

View File

@@ -18,6 +18,7 @@ import NestedNoteList from './NestedNoteList.vue';
const { Campaign } = useCampaignService(); const { Campaign } = useCampaignService();
const { t } = useI18n(); const { t } = useI18n();
const notes = ref([]); const notes = ref([]);
const media = ref([]);
const folders = ref([]); const folders = ref([]);
const actors = ref([]); const actors = ref([]);
const items = ref([]); const items = ref([]);
@@ -40,14 +41,16 @@ const activeSection = ref('notes');
const isDragOverSidebar = ref(false); const isDragOverSidebar = ref(false);
const expandedFolderIds = ref([]); const expandedFolderIds = ref([]);
const nestedNoteListRef = ref(null); const nestedNoteListRef = ref(null);
const mediaInput = ref(null);
let entryRefreshInterval; let entryRefreshInterval;
async function handleSidebarDrop(event) { async function handleSidebarDrop(event) {
if (activeSection.value !== 'notes') return; if (activeSection.value !== 'notes') return;
const noteKey = event.dataTransfer.getData('text/plain'); const row = event.dataTransfer.getData('text/plain');
if (!noteKey) return; if (!row) return;
const mediaId = row.startsWith('media:') ? row.slice(6) : null;
try { try {
await Server().post('/note/update', { id: noteKey, folder: null }); await Server().post(mediaId ? '/media/update' : '/note/update', { id: mediaId ?? row, folder: null });
if (nestedNoteListRef.value) { if (nestedNoteListRef.value) {
nestedNoteListRef.value.clearCacheAndReloadExpanded(); nestedNoteListRef.value.clearCacheAndReloadExpanded();
} else { } else {
@@ -118,6 +121,11 @@ function handleNoteDeleted(noteKey) {
notes.value = notes.value.filter(n => n.key !== noteKey); notes.value = notes.value.filter(n => n.key !== noteKey);
} }
// A media row deleted from the tree anywhere under the sidebar.
function handleMediaDeleted(mediaId) {
media.value = media.value.filter((item) => item._id !== mediaId);
}
function sectionForTarget(target) { function sectionForTarget(target) {
if (target === 'actor') return 'actors'; if (target === 'actor') return 'actors';
if (target === 'item') return 'items'; if (target === 'item') return 'items';
@@ -167,6 +175,7 @@ const campaignId = computed(() => {
async function fetchCampaignNotes() { async function fetchCampaignNotes() {
if (!campaignId.value) { if (!campaignId.value) {
notes.value = []; notes.value = [];
media.value = [];
folders.value = []; folders.value = [];
notesError.value = ''; notesError.value = '';
return; return;
@@ -180,6 +189,7 @@ async function fetchCampaignNotes() {
if (response.data.status !== 'ok') { if (response.data.status !== 'ok') {
notes.value = []; notes.value = [];
media.value = [];
folders.value = []; folders.value = [];
notesError.value = response.data.msg ?? 'Unable to load notes.'; notesError.value = response.data.msg ?? 'Unable to load notes.';
return; return;
@@ -192,8 +202,10 @@ async function fetchCampaignNotes() {
notes.value = response.data.notes.map((note) => { notes.value = response.data.notes.map((note) => {
return { key: note._id, title: note.title, text: note.content ?? '', date: note.date, color: note.color }; return { key: note._id, title: note.title, text: note.content ?? '', date: note.date, color: note.color };
}); });
media.value = response.data.media ?? [];
} catch (error) { } catch (error) {
notes.value = []; notes.value = [];
media.value = [];
folders.value = []; folders.value = [];
notesError.value = 'Unable to load notes.'; notesError.value = 'Unable to load notes.';
} finally { } finally {
@@ -503,6 +515,34 @@ function createNote() {
CreateWindow('new_note', { campaign: campaignId.value }); CreateWindow('new_note', { campaign: campaignId.value });
} }
function chooseMedia() {
mediaInput.value?.click();
}
// The picked files are uploaded to the root of the note tree, one request per file, and their
// rows join the list as each lands.
async function uploadMedia(event) {
const files = Array.from(event.target.files ?? []);
event.target.value = '';
if (!campaignId.value) return;
for (const file of files) {
const body = new FormData();
body.append('file', file);
body.append('campaign', campaignId.value);
try {
const response = await Server().post('/media/upload', body);
if (response.data.status !== 'ok') {
DisplayToast('red', t(response.data.msg || 'campaigns.media.upload-error'), 3000);
continue;
}
media.value = [response.data.media, ...media.value];
} catch (error) {
DisplayToast('red', t('campaigns.media.upload-error'), 3000);
}
}
}
function toggleSidebar() { function toggleSidebar() {
sidebarCollapsed.value = !sidebarCollapsed.value; sidebarCollapsed.value = !sidebarCollapsed.value;
} }
@@ -536,6 +576,7 @@ watch(campaignId, (newVal) => {
actors.value = []; actors.value = [];
items.value = []; items.value = [];
maps.value = []; maps.value = [];
media.value = [];
for (const sectionFolders of Object.values(entryFolders)) sectionFolders.value = []; for (const sectionFolders of Object.values(entryFolders)) sectionFolders.value = [];
collapsedFolderIds.value = []; collapsedFolderIds.value = [];
ClearAnchoredMap(); ClearAnchoredMap();
@@ -543,6 +584,7 @@ watch(campaignId, (newVal) => {
if (isEntrySection(activeSection.value)) fetchCampaignEntries(activeSection.value); if (isEntrySection(activeSection.value)) fetchCampaignEntries(activeSection.value);
} else { } else {
notes.value = []; notes.value = [];
media.value = [];
folders.value = []; folders.value = [];
actors.value = []; actors.value = [];
items.value = []; items.value = [];
@@ -559,6 +601,7 @@ onMounted(() => {
emitter.on('note-created', handleNoteCreated); emitter.on('note-created', handleNoteCreated);
emitter.on('note-renamed', handleNoteRenamed); emitter.on('note-renamed', handleNoteRenamed);
emitter.on('delete-note', handleNoteDeleted); emitter.on('delete-note', handleNoteDeleted);
emitter.on('media-deleted', handleMediaDeleted);
emitter.on('folder-saved', handleFolderSaved); emitter.on('folder-saved', handleFolderSaved);
emitter.on('folder-deleted', handleFolderDeleted); emitter.on('folder-deleted', handleFolderDeleted);
emitter.on('campaign-entry-created', handleCampaignEntryCreated); emitter.on('campaign-entry-created', handleCampaignEntryCreated);
@@ -580,6 +623,7 @@ onBeforeUnmount(() => {
emitter.off('note-created', handleNoteCreated); emitter.off('note-created', handleNoteCreated);
emitter.off('note-renamed', handleNoteRenamed); emitter.off('note-renamed', handleNoteRenamed);
emitter.off('delete-note', handleNoteDeleted); emitter.off('delete-note', handleNoteDeleted);
emitter.off('media-deleted', handleMediaDeleted);
emitter.off('folder-saved', handleFolderSaved); emitter.off('folder-saved', handleFolderSaved);
emitter.off('folder-deleted', handleFolderDeleted); emitter.off('folder-deleted', handleFolderDeleted);
emitter.off('campaign-entry-created', handleCampaignEntryCreated); emitter.off('campaign-entry-created', handleCampaignEntryCreated);
@@ -659,6 +703,10 @@ onBeforeUnmount(() => {
<button class="sidebar-action" type="button" @click="createNote" :disabled="!Campaign" :title="t('campaigns.actions.new-note')" :aria-label="t('campaigns.actions.new-note')"> <button class="sidebar-action" type="button" @click="createNote" :disabled="!Campaign" :title="t('campaigns.actions.new-note')" :aria-label="t('campaigns.actions.new-note')">
<img class="sidebar-action-icon" src="/icons/iconoir/regular/plus.svg" alt="" aria-hidden="true"> <img class="sidebar-action-icon" src="/icons/iconoir/regular/plus.svg" alt="" aria-hidden="true">
</button> </button>
<button class="sidebar-action" type="button" @click="chooseMedia" :disabled="!Campaign" :title="t('campaigns.media.upload')" :aria-label="t('campaigns.media.upload')">
<img class="sidebar-action-icon" src="/icons/iconoir/regular/media-image-plus.svg" alt="" aria-hidden="true">
</button>
<input ref="mediaInput" class="media-input" type="file" multiple @change="uploadMedia">
<button class="sidebar-action" type="button" @click="createFolder()" :disabled="!Campaign" :title="t('campaigns.actions.new-folder')" :aria-label="t('campaigns.actions.new-folder')"> <button class="sidebar-action" type="button" @click="createFolder()" :disabled="!Campaign" :title="t('campaigns.actions.new-folder')" :aria-label="t('campaigns.actions.new-folder')">
<img class="sidebar-action-icon" src="/icons/iconoir/regular/folder.svg" alt="" aria-hidden="true"> <img class="sidebar-action-icon" src="/icons/iconoir/regular/folder.svg" alt="" aria-hidden="true">
</button> </button>
@@ -684,9 +732,9 @@ onBeforeUnmount(() => {
<template v-if="activeSection === 'notes'"> <template v-if="activeSection === 'notes'">
<div v-if="loadingNotes" class="sidebar-state">{{ t('campaigns.states.loading-notes') }}</div> <div v-if="loadingNotes" class="sidebar-state">{{ t('campaigns.states.loading-notes') }}</div>
<div v-else-if="notesError" class="sidebar-state error">{{ notesError }}</div> <div v-else-if="notesError" class="sidebar-state error">{{ notesError }}</div>
<div v-else-if="folders.length === 0 && notes.length === 0" class="sidebar-state">{{ t('campaigns.states.empty-notes') }}</div> <div v-else-if="folders.length === 0 && notes.length === 0 && media.length === 0" class="sidebar-state">{{ t('campaigns.states.empty-notes') }}</div>
<NestedNoteList v-else ref="nestedNoteListRef" <NestedNoteList v-else ref="nestedNoteListRef"
:parent-folder-id="null" :folders="folders" :notes="rootNotes" :campaign-id="campaignId" :parent-folder-id="null" :folders="folders" :notes="rootNotes" :media="media" :campaign-id="campaignId"
:expanded-folder-ids="expandedFolderIds" @open-note="openNote" :expanded-folder-ids="expandedFolderIds" @open-note="openNote"
@reload-notes="fetchCampaignNotes" @toggle-expanded-folder="toggleExpandedFolder" /> @reload-notes="fetchCampaignNotes" @toggle-expanded-folder="toggleExpandedFolder" />
</template> </template>
@@ -706,7 +754,10 @@ onBeforeUnmount(() => {
@toggle="toggleFolder(row.folder._id)" @toggle="toggleFolder(row.folder._id)"
/> />
<div v-else class="entity-entry" :style="rowIndent(row.depth)" role="button" tabindex="0" draggable="true" :title="t('campaigns.map.tokens.drag')" @click="openCharacterSheet(row.item)" @keydown.enter="openCharacterSheet(row.item)" @keydown.space.prevent="openCharacterSheet(row.item)" @dragstart="startActorDrag($event, row.item)" @contextmenu.prevent="showEntryMenu(row.item, 'actor')"> <div v-else class="entity-entry" :style="rowIndent(row.depth)" role="button" tabindex="0" draggable="true" :title="t('campaigns.map.tokens.drag')" @click="openCharacterSheet(row.item)" @keydown.enter="openCharacterSheet(row.item)" @keydown.space.prevent="openCharacterSheet(row.item)" @dragstart="startActorDrag($event, row.item)" @contextmenu.prevent="showEntryMenu(row.item, 'actor')">
<span class="entity-entry-title">
<img class="entity-entry-icon" src="/icons/iconoir/regular/user.svg" alt="" aria-hidden="true">
<span class="entity-entry-name">{{ row.item.name }}</span> <span class="entity-entry-name">{{ row.item.name }}</span>
</span>
<span class="entity-entry-meta">{{ entrySummary(row.item) }}</span> <span class="entity-entry-meta">{{ entrySummary(row.item) }}</span>
</div> </div>
</template> </template>
@@ -731,6 +782,7 @@ onBeforeUnmount(() => {
<span v-if="row.item.image" class="entity-entry-image" aria-hidden="true"> <span v-if="row.item.image" class="entity-entry-image" aria-hidden="true">
<img :src="itemImageUrl(row.item.image)" alt=""> <img :src="itemImageUrl(row.item.image)" alt="">
</span> </span>
<img v-else class="entity-entry-icon" src="/icons/iconoir/regular/box.svg" alt="" aria-hidden="true">
<span class="entity-entry-name" :class="rarityClass(row.item)">{{ row.item.name }}</span> <span class="entity-entry-name" :class="rarityClass(row.item)">{{ row.item.name }}</span>
</span> </span>
</div> </div>
@@ -752,10 +804,13 @@ onBeforeUnmount(() => {
@toggle="toggleFolder(row.folder._id)" @toggle="toggleFolder(row.folder._id)"
/> />
<div v-else class="entity-entry" :style="rowIndent(row.depth)" :class="{ anchored: isAnchoredMap(row.item) }" role="button" tabindex="0" @click="openMapViewer(row.item)" @keydown.enter="openMapViewer(row.item)" @keydown.space.prevent="openMapViewer(row.item)" @contextmenu.prevent="showEntryMenu(row.item, 'map')"> <div v-else class="entity-entry" :style="rowIndent(row.depth)" :class="{ anchored: isAnchoredMap(row.item) }" role="button" tabindex="0" @click="openMapViewer(row.item)" @keydown.enter="openMapViewer(row.item)" @keydown.space.prevent="openMapViewer(row.item)" @contextmenu.prevent="showEntryMenu(row.item, 'map')">
<span class="entity-entry-title">
<img class="entity-entry-icon" src="/icons/iconoir/regular/map.svg" alt="" aria-hidden="true">
<span class="entity-entry-name-row"> <span class="entity-entry-name-row">
<span class="entity-entry-name">{{ row.item.name }}</span> <span class="entity-entry-name">{{ row.item.name }}</span>
<span v-if="isAnchoredMap(row.item)" class="entity-entry-sync">{{ t('campaigns.map.anchored') }}</span> <span v-if="isAnchoredMap(row.item)" class="entity-entry-sync">{{ t('campaigns.map.anchored') }}</span>
</span> </span>
</span>
<span class="entity-entry-meta">{{ mapSummary(row.item) }}</span> <span class="entity-entry-meta">{{ mapSummary(row.item) }}</span>
<span v-if="!row.item.image" class="entity-entry-description">{{ t('campaigns.map.no-image') }}</span> <span v-if="!row.item.image" class="entity-entry-description">{{ t('campaigns.map.no-image') }}</span>
</div> </div>
@@ -850,6 +905,7 @@ onBeforeUnmount(() => {
} }
.sidebar-header-actions { display: flex; align-items: center; gap: 4px; } .sidebar-header-actions { display: flex; align-items: center; gap: 4px; }
.media-input { display: none; }
.sidebar-header-actions .sidebar-action { width: 30px; height: 30px; } .sidebar-header-actions .sidebar-action { width: 30px; height: 30px; }
.sidebar-header-actions .sidebar-action-icon { width: 16px; height: 16px; } .sidebar-header-actions .sidebar-action-icon { width: 16px; height: 16px; }
@@ -923,6 +979,8 @@ onBeforeUnmount(() => {
} }
.entity-entry-meta, .entity-entry-description { font-size: 12px; opacity: 0.72; } .entity-entry-meta, .entity-entry-description { font-size: 12px; opacity: 0.72; }
.entity-entry-description { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; overflow: hidden; } .entity-entry-description { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; overflow: hidden; }
/* Every entry row leads with an icon of what it is: an actor, an item, a map. */
.entity-entry-icon { width: 16px; height: 16px; flex: 0 0 16px; filter: invert(var(--color-icon-invert)); }
/* An item row leads with the item's own icon on the left of its name, standing in for the /* An item row leads with the item's own icon on the left of its name, standing in for the
"SYNCED" text it used to show (Syndria98/dragonroll#53). */ "SYNCED" text it used to show (Syndria98/dragonroll#53). */
.entity-entry-title { display: flex; align-items: center; gap: 9px; min-width: 0; } .entity-entry-title { display: flex; align-items: center; gap: 9px; min-width: 0; }

View File

@@ -2,13 +2,15 @@
import { ref, onBeforeUnmount, onMounted, watch } from 'vue'; import { ref, onBeforeUnmount, onMounted, watch } from 'vue';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
import { BuildColorMenu } from '~/services/EntryColors'; import { BuildColorMenu } from '~/services/EntryColors';
import Server from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { CreateWindow } from '~/services/Windows'; import { CreateWindow } from '~/services/Windows';
import { ShowContextMenu, HideContextMenu } from '~/services/ContextMenu'; import { ShowContextMenu, HideContextMenu } from '~/services/ContextMenu';
const props = defineProps({ const props = defineProps({
folders: Array, folders: Array,
notes: Array, notes: Array,
// Media files standing beside the notes at this level of the tree.
media: { type: Array, default: () => [] },
campaignId: String, campaignId: String,
level: { type: Number, default: 0 }, level: { type: Number, default: 0 },
parentFolderId: String, parentFolderId: String,
@@ -44,6 +46,7 @@ onMounted(() => {
emitter.on('note-created', handleNoteCreated); emitter.on('note-created', handleNoteCreated);
emitter.on('note-renamed', handleNoteRenamed); emitter.on('note-renamed', handleNoteRenamed);
emitter.on('delete-note', handleNoteDeleted); emitter.on('delete-note', handleNoteDeleted);
emitter.on('media-deleted', handleMediaDeleted);
emitter.on('folder-saved', handleFolderSaved); emitter.on('folder-saved', handleFolderSaved);
}); });
@@ -51,6 +54,7 @@ onBeforeUnmount(() => {
emitter.off('note-created', handleNoteCreated); emitter.off('note-created', handleNoteCreated);
emitter.off('note-renamed', handleNoteRenamed); emitter.off('note-renamed', handleNoteRenamed);
emitter.off('delete-note', handleNoteDeleted); emitter.off('delete-note', handleNoteDeleted);
emitter.off('media-deleted', handleMediaDeleted);
emitter.off('folder-saved', handleFolderSaved); emitter.off('folder-saved', handleFolderSaved);
}); });
@@ -80,6 +84,12 @@ function handleNoteDeleted(noteKey) {
} }
} }
function handleMediaDeleted(mediaId) {
for (const entry of Object.values(folderContentCache.value)) {
entry.media = entry.media.filter((m) => m._id !== mediaId);
}
}
function handleFolderSaved(folder) { function handleFolderSaved(folder) {
const folderId = folder?._id ?? folder?.id; const folderId = folder?._id ?? folder?.id;
if (!folderId) return; if (!folderId) return;
@@ -98,6 +108,7 @@ function loadFolderContents(folderId) {
if (res.data.status !== 'ok') return; if (res.data.status !== 'ok') return;
folderContentCache.value[folderId] = { folderContentCache.value[folderId] = {
notes: res.data.notes.map(n => ({ key: n._id, title: n.title, text: n.content || '', color: n.color })), notes: res.data.notes.map(n => ({ key: n._id, title: n.title, text: n.content || '', color: n.color })),
media: res.data.media || [],
subfolders: res.data.subfolders || [] subfolders: res.data.subfolders || []
}; };
}).catch(() => {}).finally(() => { }).catch(() => {}).finally(() => {
@@ -113,6 +124,10 @@ function getFolderSubfolders(folderId) {
return folderContentCache.value[folderId]?.subfolders || []; return folderContentCache.value[folderId]?.subfolders || [];
} }
function getFolderMedia(folderId) {
return folderContentCache.value[folderId]?.media || [];
}
// Load contents for all currently-expanded folders // Load contents for all currently-expanded folders
function loadExpandedFolders() { function loadExpandedFolders() {
const idsToLoad = props.level === 0 const idsToLoad = props.level === 0
@@ -125,26 +140,32 @@ function loadExpandedFolders() {
} }
} }
// A row dragged into a folder is either a note (its key) or a media file ("media:<id>").
async function moveDraggedRow(payload, folderId) {
const mediaId = payload.startsWith('media:') ? payload.slice(6) : null;
await Server().post(mediaId ? '/media/update' : '/note/update', { id: mediaId ?? payload, folder: folderId });
}
async function handleDropNoteOnFolder(folderId, event) { async function handleDropNoteOnFolder(folderId, event) {
const noteKey = event.dataTransfer.getData('text/plain'); const row = event.dataTransfer.getData('text/plain');
if (!noteKey || !folderId) return; if (!row || !folderId) return;
dragHoveredFolderId.value = null; dragHoveredFolderId.value = null;
try { try {
await Server().post('/note/update', { id: noteKey, folder: folderId }); await moveDraggedRow(row, folderId);
clearCacheAndReloadExpanded(); clearCacheAndReloadExpanded();
} catch (e) {} } catch (e) {}
} }
async function handleDropNoteOnRoot(event) { async function handleDropNoteOnRoot(event) {
const noteKey = event.dataTransfer.getData('text/plain'); const row = event.dataTransfer.getData('text/plain');
if (!noteKey) return; if (!row) return;
dragHoveredFolderId.value = null; dragHoveredFolderId.value = null;
try { try {
await Server().post('/note/update', { id: noteKey, folder: null }); await moveDraggedRow(row, null);
clearCacheAndReloadExpanded(); clearCacheAndReloadExpanded();
} catch (e) {} } catch (e) {}
} }
@@ -172,6 +193,31 @@ function startDragNote(event, note) {
event.dataTransfer.effectAllowed = 'move'; event.dataTransfer.effectAllowed = 'move';
} }
// A media row drags into a folder like a note does, under a prefixed key so the drop knows
// which of the two lists it is moving.
function startDragMedia(event, media) {
event.dataTransfer.setData('text/plain', `media:${media._id}`);
event.dataTransfer.effectAllowed = 'move';
}
// The icon a media row leads with, the way the sidebar tells a picture from a sound at a glance.
function mediaIcon(media) {
const type = media?.mimeType ?? '';
if (type.startsWith('image/')) return '/icons/iconoir/regular/media-image.svg';
if (type.startsWith('audio/')) return '/icons/iconoir/regular/music-note.svg';
if (type.startsWith('video/')) return '/icons/iconoir/regular/media-video.svg';
if (type === 'application/pdf') return '/icons/iconoir/regular/page.svg';
return '/icons/iconoir/regular/attachment.svg';
}
function mediaUrl(media) {
return media?.file ? `${getBaseUrl()}/public/${media.file}` : '';
}
function openMedia(media) {
CreateWindow('media_viewer', { media });
}
function setDragHover(id) { function setDragHover(id) {
dragHoveredFolderId.value = id; dragHoveredFolderId.value = id;
} }
@@ -194,6 +240,18 @@ function buildNoteContextMenu(note) {
]; ];
} }
function buildMediaContextMenu(media) {
return [
{ name: 'Open', icon: '/icons/iconoir/regular/attachment.svg', action: () => openMedia(media) },
{
name: 'Move to Folder...', icon: '/icons/iconoir/regular/folder.svg',
context: buildMediaMoveToMenu(media)
},
{ divider: true },
{ name: 'Delete', icon: '/icons/iconoir/regular/trash.svg', action: () => deleteMedia(media) }
];
}
function buildFolderContextMenu(folder) { function buildFolderContextMenu(folder) {
if (!folder || !folder._id) return []; if (!folder || !folder._id) return [];
return [ return [
@@ -262,6 +320,35 @@ async function deleteFolder(folderId) {
HideContextMenu(); HideContextMenu();
} }
function buildMediaMoveToMenu(media) {
const moveItems = (props.folders || []).map(folder => ({
name: folder.name, icon: '/icons/iconoir/regular/folder.svg', action: () => moveMediaToFolder(media, folder._id)
}));
if (moveItems.length > 0) moveItems.push({ divider: true });
moveItems.push({ name: '(Root)', icon: '/icons/iconoir/regular/attachment.svg', action: () => moveMediaToFolder(media, null) });
return moveItems;
}
async function moveMediaToFolder(media, folderId) {
try {
const response = await Server().post('/media/update', { id: media._id, folder: folderId || null });
if (response.data.status !== 'ok') return;
clearCacheAndReloadExpanded();
} catch (e) {}
HideContextMenu();
}
async function deleteMedia(media) {
try {
const response = await Server().post('/media/delete', { id: media._id });
if (response.data.status === 'ok') emitter.emit('media-deleted', media._id);
} catch (error) {} finally {
HideContextMenu();
}
}
async function moveNoteToFolder(note, folderId) { async function moveNoteToFolder(note, folderId) {
try { try {
const response = await Server().post('/note/update', { id: note.key, folder: folderId || null }); const response = await Server().post('/note/update', { id: note.key, folder: folderId || null });
@@ -308,6 +395,7 @@ function createNoteInFolder(folderId) {
v-if="expandedFolderIds.includes(folder._id)" v-if="expandedFolderIds.includes(folder._id)"
:folders="getFolderSubfolders(folder._id)" :folders="getFolderSubfolders(folder._id)"
:notes="getFolderNotes(folder._id)" :notes="getFolderNotes(folder._id)"
:media="getFolderMedia(folder._id)"
:campaign-id="campaignId" :campaign-id="campaignId"
:level="level + 1" :level="level + 1"
:parent-folder-id="folder._id" :parent-folder-id="folder._id"
@@ -323,15 +411,24 @@ function createNoteInFolder(folderId) {
<!-- Notes at this level --> <!-- Notes at this level -->
<template v-for="note in notes" :key="note.key"> <template v-for="note in notes" :key="note.key">
<button type="button" class="note-link" :class="{ 'has-color': !!note.color }" :style="entryColorStyle(note)" draggable="true" @dragstart="startDragNote($event, note)" @click.stop="$emit('open-note', note)" @contextmenu.prevent="ShowContextMenu(buildNoteContextMenu(note))"> <button type="button" class="note-link" :class="{ 'has-color': !!note.color }" :style="entryColorStyle(note)" draggable="true" @dragstart="startDragNote($event, note)" @click.stop="$emit('open-note', note)" @contextmenu.prevent="ShowContextMenu(buildNoteContextMenu(note))">
<img class="note-link-icon" src="/icons/iconoir/regular/journal-page.svg" alt="" aria-hidden="true">
<span class="note-link-title">{{ note.title }}</span> <span class="note-link-title">{{ note.title }}</span>
</button> </button>
</template> </template>
<!-- Media files at this level, VSCode-explorer style: the type's icon, then the file name -->
<template v-for="item in media" :key="item._id">
<button type="button" class="note-link media-link" draggable="true" :title="item.name" @dragstart="startDragMedia($event, item)" @click.stop="openMedia(item)" @contextmenu.prevent="ShowContextMenu(buildMediaContextMenu(item))">
<img class="media-link-icon" :src="mediaIcon(item)" alt="" aria-hidden="true">
<span class="media-link-name">{{ item.name }}</span>
</button>
</template>
<!-- Drop zone for root-level notes --> <!-- Drop zone for root-level notes -->
<div v-if="level === 0" class="root-drop-zone" :class="{ 'drag-over': dragHoveredFolderId === 'root' }" @drop.stop="handleDropNoteOnRoot($event)"> <div v-if="level === 0" class="root-drop-zone" :class="{ 'drag-over': dragHoveredFolderId === 'root' }" @drop.stop="handleDropNoteOnRoot($event)">
</div> </div>
<div v-if="folders.length === 0 && (!notes || notes.length === 0) && level === 0" class="sidebar-state">Empty</div> <div v-if="folders.length === 0 && (!notes || notes.length === 0) && (!media || media.length === 0) && level === 0" class="sidebar-state">Empty</div>
</div> </div>
</template> </template>
@@ -353,10 +450,17 @@ function createNoteInFolder(folderId) {
.folder-children { padding-left: 20px; margin-top: 2px; cursor: default; } .folder-children { padding-left: 20px; margin-top: 2px; cursor: default; }
.folder-children.drag-over { background: #ffffff22; border-radius: 10px; } .folder-children.drag-over { background: #ffffff22; border-radius: 10px; }
.note-link { width: 100%; padding: 6px; margin: 0; box-shadow: none; border: none; display: flex; flex-direction: column; align-items: flex-start; text-align: left; cursor: grab; border-radius: 8px; } .note-link { width: 100%; padding: 6px; margin: 0; box-shadow: none; border: none; display: flex; flex-direction: row; align-items: center; gap: 8px; text-align: left; cursor: grab; border-radius: 8px; }
.note-link.has-color { background: color-mix(in srgb, var(--entry-color) 32%, transparent); } .note-link.has-color { background: color-mix(in srgb, var(--entry-color) 32%, transparent); }
.note-link.has-color:hover { background: color-mix(in srgb, var(--entry-color) 50%, transparent); } .note-link.has-color:hover { background: color-mix(in srgb, var(--entry-color) 50%, transparent); }
.note-link-title { font-weight: 600; word-break: break-word; } /* Every note row leads with the page icon, like a media row with the icon of its type. */
.note-link-icon { width: 15px; height: 15px; flex: 0 0 15px; filter: invert(var(--color-icon-invert)); }
.note-link-title { flex: 1; min-width: 0; font-weight: 600; word-break: break-word; }
/* Media rows share the note row's box, with the file type's icon where a note has none. */
.media-link { flex-direction: row; align-items: center; gap: 8px; }
.media-link-icon { width: 15px; height: 15px; flex: 0 0 15px; filter: invert(var(--color-icon-invert)); }
.media-link-name { min-width: 0; font-weight: 500; text-align: left; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.sidebar-state { padding: 12px; border-radius: 10px; background: var(--color-background-soft); font-size: 14px; } .sidebar-state { padding: 12px; border-radius: 10px; background: var(--color-background-soft); font-size: 14px; }

View File

@@ -13,6 +13,13 @@ function OpenCampaignSettings() {
CreateWindow('campaign_settings', { campaign: Campaign.value }); CreateWindow('campaign_settings', { campaign: Campaign.value });
} }
function OpenDocumentation() {
// La documentació és una finestra que va davant de l'espai de treball, així que les notes
// obertes no es perden. CreateWindow deixa sola una finestra que ja és oberta: tornar a
// prémer el botó no la torna a la primera pàgina.
CreateWindow('documentation');
}
function ExitCampaign() { function ExitCampaign() {
// Torn al menú principal: neteja la campanya (i el localStorage), amaga // Torn al menú principal: neteja la campanya (i el localStorage), amaga
// l'espai de treball i reobre el menú // l'espai de treball i reobre el menú
@@ -35,11 +42,11 @@ function ExitCampaign() {
<TopSearchBar></TopSearchBar> <TopSearchBar></TopSearchBar>
</div> </div>
<div class="right"> <div class="right">
<!-- La documentació és una pàgina a part (/docs), i una pestanya nova deixa la <!-- La documentació s'obre en una finestra seva, davant de la campanya: les notes
campanya tal com era: les notes obertes no es perden. --> obertes no es perden i no cal obrir una pestanya nova. -->
<a class="btn-primary docs-button sound-click" href="/docs" target="_blank" rel="noopener noreferrer"> <button class="btn-primary settings-button docs-button sound-click" type="button" @click="OpenDocumentation">
{{ $t('main-menu.documentation') }} {{ $t('main-menu.documentation') }}
</a> </button>
<button class="btn-primary settings-button sound-click" type="button" @click="OpenCampaignSettings"> <button class="btn-primary settings-button sound-click" type="button" @click="OpenCampaignSettings">
{{ $t('main-menu.settings') }} {{ $t('main-menu.settings') }}
</button> </button>
@@ -90,29 +97,6 @@ function ExitCampaign() {
padding: 5px 10px; padding: 5px 10px;
} }
/* L'enllaç a la documentació és un `<a>` i els botons estan estilats per element, així
que li toca portar el mateix look que els dos que té al costat. */
.docs-button {
padding: 5px 10px;
margin: 5px 0;
font-size: 15px;
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-button:hover {
background-color: var(--color-button-hover);
}
.docs-button:active {
background-color: var(--color-button-active);
}
.top-bar-title { .top-bar-title {
padding: 10px; padding: 10px;
display: flex; display: flex;

View File

@@ -0,0 +1,323 @@
<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');
const isMedia = computed(() => target.value?.type === 'media');
const isImage = computed(() => String(entry.value?.mimeType ?? '').startsWith('image/'));
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 mediaUrl = computed(() => entry.value?.file ? `${getBaseUrl()}/public/${entry.value.file}` : '');
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-if="entry && isMedia" class="embedded-media">
<img v-if="isImage" class="embed-image" :src="mediaUrl" :alt="entry.name">
<a v-else class="embed-file" :href="mediaUrl" target="_blank" rel="noopener">{{ entry.name }}</a>
</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); }
/* An embedded upload: an image fills the note's width, any other file is offered as a link. */
.embedded-media { display: inline-block; max-width: 100%; margin: 8px 0; vertical-align: top; }
.embed-image {
display: block;
max-width: 100%;
height: auto;
border: 1px solid var(--color-border);
border-radius: 8px;
}
.embed-file { color: var(--color-link); word-break: break-word; }
.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

@@ -0,0 +1,227 @@
<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,12 +1,21 @@
<script setup> <script setup>
import { onMounted, onUnmounted, ref, createApp } from 'vue'; import { onMounted, onUnmounted, ref, nextTick, 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, ParseMarkdown } from '~/services/Marker'; import { GetWidget, GetWidgetRegistry, ParseMarkdown } from '~/services/Marker';
import { BuildWidgetSuggestions, FilterWidgetSuggestions, FindWidgetTrigger, InsertWidgetSuggestion } from '~/services/WidgetAutocomplete';
import { FilterLinkSuggestions, FindLinkTarget, FindLinkTrigger, InsertLinkSuggestion } from '~/services/LinkAutocomplete';
import { LoadLinkEntry, LoadLinkTargets } from '~/services/LinkTargets';
import { AnchorMap } from '~/services/Content';
import { ClearWindow, CreateWindow, GetFirstWindowId } from '~/services/Windows';
import { useCampaignService } from '~/services/Campaign';
import 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']);
@@ -24,6 +33,228 @@ 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(target.type === 'media' ? 'campaigns.sections.media' : `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;
} }
@@ -81,6 +312,201 @@ 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);
return;
}
if (target.type === 'media') {
const media = await LoadLinkEntry(campaignId.value, 'media', target.id);
if (media) CreateWindow('media_viewer', { media });
}
}
// 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(){
@@ -88,11 +514,14 @@ 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);
} }
@@ -107,6 +536,9 @@ 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();
}); });
@@ -120,6 +552,8 @@ 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();
}); });
@@ -128,6 +562,8 @@ 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
@@ -280,7 +716,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')) return; if (e.target.closest('a, .vue-link')) return;
const selection = window.getSelection(); const selection = window.getSelection();
if (selection && selection.toString()) return; if (selection && selection.toString()) return;
@@ -325,13 +761,39 @@ function setupHeadings() {
<span>{{ title }}</span> <span>{{ title }}</span>
</div> </div>
<div class="note-content-container"> <div class="note-content-container">
<textarea v-model="sourceText" class="full-editor" v-if="editingMode"></textarea> <template v-if="editingMode">
<textarea
ref="editor"
v-model="sourceText"
class="full-editor"
@input="onEditorInput"
@click="onEditorClick"
@keydown="onEditorKeydown"
@blur="closeSuggestions"
></textarea>
<SuggestionMenu
v-if="suggestions.length"
:suggestions="suggestions"
:selected="selectedSuggestion"
:position="suggestionStyle"
@select="applySuggestion"
@hover="onSuggestionHover"
/>
</template>
<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>
@@ -439,6 +901,7 @@ width: 100%;
.note-content-container { .note-content-container {
width: 100%; width: 100%;
position: relative;
} }
.note-content :deep(img) { .note-content :deep(img) {
@@ -446,4 +909,29 @@ 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

@@ -0,0 +1,73 @@
<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,23 +1,28 @@
<script setup> <script setup>
import { ref,onMounted } from 'vue'; import { ref,onMounted,onUnmounted } 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);
emitter.on("status-bar-update", (state) => { const handleStatusUpdate = (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() {
statusIcon.value.src = this.src; // The update can arrive (or finish loading) while the bar is not mounted.
if (statusIcon.value) statusIcon.value.src = this.src;
}; };
statusMessage.value.innerText = state.text; if (statusMessage.value) 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

@@ -301,88 +301,8 @@ useHead({
color: var(--color-link); color: var(--color-link);
} }
/* El markdown renderitzat: tot dins de .docs-markdown, perquè ve de v-html. */ /* El markdown renderitzat ve estilat a assets/css/main.scss, sota .docs-markdown, perquè la
.docs-markdown :deep(h1) { finestra de documentació (windows/DocumentationWindow.vue) se'l serveix igualment. */
margin: 0 0 14px 0;
font-family: 'MrEavesRemake', serif;
font-size: 2rem;
font-weight: normal;
line-height: 1.2;
}
.docs-markdown :deep(h2) {
margin: 30px 0 10px 0;
padding-bottom: 4px;
border-bottom: 1px solid var(--color-border);
font-family: 'MrEavesRemake', serif;
font-size: 1.35rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown :deep(h3) {
margin: 22px 0 8px 0;
font-family: 'MrEavesRemake', serif;
font-size: 1.1rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown :deep(p),
.docs-markdown :deep(li) {
line-height: 1.65;
}
.docs-markdown :deep(ul),
.docs-markdown :deep(ol) {
margin: 10px 0;
padding-left: 1.5em;
}
.docs-markdown :deep(a) {
color: var(--color-link);
}
.docs-markdown :deep(code) {
padding: 1px 5px;
border-radius: 4px;
background-color: var(--color-background-light);
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
font-size: 0.9em;
}
.docs-markdown :deep(pre) {
margin: 14px 0;
padding: 12px 14px;
border: 1px solid var(--color-border);
border-radius: 8px;
background-color: var(--color-background-light);
overflow-x: auto;
}
.docs-markdown :deep(pre code) {
padding: 0;
background-color: transparent;
}
.docs-markdown :deep(table) {
margin: 14px 0;
border-collapse: collapse;
width: 100%;
}
.docs-markdown :deep(th),
.docs-markdown :deep(td) {
padding: 7px 10px;
border: 1px solid var(--color-border);
text-align: left;
vertical-align: top;
line-height: 1.5;
}
.docs-markdown :deep(th) {
background-color: var(--color-background-light);
}
/* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del /* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del
text en lloc d'estirats cap al cantó dret de la pantalla. */ text en lloc d'estirats cap al cantó dret de la pantalla. */

View File

@@ -171,7 +171,6 @@ 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, Top } from '@/services/Windows'; import { SetupHandle, SetSize, ResetPosition, ClearWindow, CreateWindow, GetFirstWindowId, 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,6 +100,11 @@ 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 ?? ''
@@ -233,6 +238,14 @@ 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;
@@ -519,8 +532,20 @@ 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 class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p> <p v-else-if="form.traits" class="sheet-copy">{{ form.traits }}</p>
<p v-else-if="!form.features.length" class="sheet-copy">{{ $t('campaigns.character-sheet.empty-traits') }}</p>
</section> </section>
</main> </main>
@@ -636,8 +661,18 @@ 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

@@ -1,6 +1,6 @@
<script setup> <script setup>
import { onBeforeUnmount, onMounted, ref } from 'vue'; import { onBeforeUnmount, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, ClearWindow } 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 from '~/services/Server'; import Server from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -34,6 +34,7 @@ function initialForm() {
const form = ref(initialForm()); const form = ref(initialForm());
onMounted(() => { onMounted(() => {
Top(wrapper);
SetupHandle(id, handle); SetupHandle(id, handle);
SetSize(id, isActor ? { width: 420, height: 220 } : { width: 500, height: 560 }); SetSize(id, isActor ? { width: 420, height: 220 } : { width: 500, height: 560 });
ResetPosition(id, 'center'); ResetPosition(id, 'center');
@@ -71,7 +72,6 @@ async function saveEntry() {
<WindowHandle :window="id" ref="handle" /> <WindowHandle :window="id" ref="handle" />
<div class="body"> <div class="body">
<h3>{{ $t(editing ? 'campaigns.item.edit' : (isActor ? 'campaigns.actor.new' : 'campaigns.item.new')) }}</h3> <h3>{{ $t(editing ? 'campaigns.item.edit' : (isActor ? 'campaigns.actor.new' : 'campaigns.item.new')) }}</h3>
<p v-if="!isActor && editing?.foundryItemId" class="sync-note">{{ $t('campaigns.item.foundry-sync-note') }}</p>
<form @submit.prevent="saveEntry"> <form @submit.prevent="saveEntry">
<label class="form-field"> <label class="form-field">
<span>{{ $t('campaigns.fields.name') }}</span> <span>{{ $t('campaigns.fields.name') }}</span>
@@ -134,7 +134,6 @@ async function saveEntry() {
.window-wrapper { display: flex; align-items: center; flex-direction: column; } .window-wrapper { display: flex; align-items: center; flex-direction: column; }
.body { width: 100%; padding: 10px 18px 16px; overflow-y: auto; } .body { width: 100%; padding: 10px 18px 16px; overflow-y: auto; }
h3 { margin: 0 0 12px; font-family: MrEavesRemake; } h3 { margin: 0 0 12px; font-family: MrEavesRemake; }
.sync-note { margin: -8px 0 12px; font-size: 12px; opacity: 0.72; }
form { display: flex; flex-direction: column; gap: 10px; } form { display: flex; flex-direction: column; gap: 10px; }
.form-field { min-width: 0; display: flex; flex-direction: column; gap: 4px; font-size: 13px; } .form-field { min-width: 0; display: flex; flex-direction: column; gap: 4px; font-size: 13px; }
.form-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; } .form-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }

View File

@@ -0,0 +1,261 @@
<script setup>
import { computed, nextTick, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, Top, SetResizable, SetMinSize } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import { GetDocsFirstSlug, GetDocsNav, GetDocsPage } from '~/services/Docs';
// La documentació dins d'una finestra: el sumari a l'esquerra i la pàgina al centre, amb el
// mateix contingut de app/content/docs que la pàgina pública de /docs (mira ~/services/Docs.js).
// El sumari no porta enlloc amb rutes sinó amb estat propi, així obrir la documentació dins
// d'una campanya no deixa les notes obertes enrere.
const props = defineProps(['data']);
const id = props.data.id;
const handle = ref(null);
const wrapper = ref(null);
const reading = ref(null);
const nav = GetDocsNav();
const slug = ref(GetDocsFirstSlug());
const page = computed(() => GetDocsPage(slug.value));
function GoTo(target) {
if (!GetDocsPage(target)) return;
slug.value = target;
// Cada pàgina es comença a dalt, com faria el navegador.
nextTick(() => { if (reading.value) reading.value.scrollTop = 0; });
}
// Els enllaços que el markdown porta a dins (`[Foundry](/docs/foundry)`) i els seus apartats
// s'han de seguir dins la finestra: sortir-ne per via d'una ruta deixaria la campanya enrere.
function OnContentClick(event) {
const link = event.target?.closest?.('a');
if (!link) return;
const href = link.getAttribute('href') || '';
// Un apartat de la pàgina: el que fila és la columna de lectura, no la pantalla.
if (href.startsWith('#')) {
if (href.length < 2) return;
const heading = reading.value?.querySelector('#' + CSS.escape(href.slice(1)));
if (!heading) return;
event.preventDefault();
heading.scrollIntoView({ block: 'start' });
return;
}
const inside = /^\/docs\/?([a-z0-9-]*)$/.exec(href);
if (inside) {
event.preventDefault();
GoTo(inside[1] || GetDocsFirstSlug());
return;
}
// Fora de la documentació: una pestanya nova, que la campanya no es mou d'aquí.
if (href && !href.startsWith('/')) {
event.preventDefault();
window.open(href, '_blank', 'noopener');
}
}
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, {
width: Math.max(620, Math.min(1000, window.innerWidth - 24)),
height: Math.max(420, Math.min(780, window.innerHeight - 32))
});
ResetPosition(id, 'center');
SetResizable(id, true);
SetMinSize(id, { width: 620, height: 420 });
});
</script>
<template>
<div class="window-wrapper" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle"></WindowHandle>
<!-- Body -->
<div class="docs-body">
<aside class="docs-contents" :aria-label="$t('docs.contents')">
<section v-for="group in nav" :key="group.key" class="docs-group">
<h2 class="docs-group-title">{{ $t(`docs.groups.${group.key}`) }}</h2>
<ul>
<li v-for="entry in group.pages" :key="entry.slug">
<button
type="button"
class="docs-nav-link sound-click"
:class="{ active: entry.slug === slug }"
v-on:click="GoTo(entry.slug)"
>{{ entry.title }}</button>
</li>
</ul>
</section>
</aside>
<div class="docs-reading" ref="reading">
<template v-if="page">
<article class="docs-article" v-on:click="OnContentClick">
<p class="docs-kicker">{{ $t(`docs.groups.${page.group}`) }}</p>
<!-- El contingut és markdown nostre, de app/content/docs -->
<div class="docs-markdown" v-html="page.html"></div>
</article>
<nav class="docs-pager">
<button
v-if="page.previous"
type="button"
class="docs-pager-link sound-click"
v-on:click="GoTo(page.previous.slug)"
>
<span class="docs-pager-label">{{ $t('docs.previous') }}</span>
<strong>{{ page.previous.title }}</strong>
</button>
<button
v-if="page.next"
type="button"
class="docs-pager-link next sound-click"
v-on:click="GoTo(page.next.slug)"
>
<span class="docs-pager-label">{{ $t('docs.next') }}</span>
<strong>{{ page.next.title }}</strong>
</button>
</nav>
</template>
<article v-else class="docs-article">
<h1>{{ $t('docs.title') }}</h1>
<p>{{ $t('docs.not-found', { page: slug }) }}</p>
</article>
</div>
</div>
</div>
</template>
<style scoped lang="scss">
/* El sumari i la lectura són les dues columnes d'una finestra: cada una fila per la seva,
res d'una pantalla d'alçada ni de sticky, que la finestra ja és el que es mou. */
.docs-body {
display: flex;
flex: 1;
width: 100%;
min-height: 0;
}
.docs-contents {
flex: 0 0 212px;
min-width: 0;
box-sizing: border-box;
padding: 14px 10px;
border-right: 1px solid var(--color-border);
overflow-y: auto;
display: flex;
flex-direction: column;
gap: 16px;
}
.docs-group-title {
margin: 0 0 6px 0;
font-family: 'MrEavesRemake', serif;
font-size: 0.78rem;
font-weight: normal;
letter-spacing: 0.08em;
text-transform: uppercase;
color: var(--color-gray);
}
.docs-contents ul {
margin: 0;
padding: 0;
list-style: none;
display: flex;
flex-direction: column;
gap: 2px;
}
/* Les pàgines del sumari són botons: una finestra no té rutes a seguir. */
.docs-nav-link {
width: 100%;
margin: 0;
padding: 6px 9px;
border: none;
border-radius: 6px;
box-shadow: none;
background-color: transparent;
font-size: 0.95rem;
line-height: 1.35;
text-align: left;
color: var(--color-text);
}
.docs-nav-link:hover {
background-color: var(--color-hover);
}
.docs-nav-link.active {
background-color: var(--color-background-soft);
color: var(--color-link);
}
.docs-reading {
flex: 1;
min-width: 0;
box-sizing: border-box;
padding: 20px 26px 40px 26px;
overflow-y: auto;
/* El que es llegeix es pot seleccionar, encara que una finestra no ho permeti per defecte. */
user-select: text;
}
/* La columna de lectura, centrada dins l'espai que deixa el sumari. */
.docs-article,
.docs-pager {
width: 100%;
max-width: 720px;
margin-inline: auto;
}
.docs-kicker {
margin: 0 0 4px 0;
font-size: 0.8rem;
letter-spacing: 0.08em;
text-transform: uppercase;
color: var(--color-gray);
}
.docs-pager {
margin-top: 30px;
padding-top: 16px;
border-top: 1px solid var(--color-border);
display: flex;
gap: 14px;
}
/* Són els botons d'abans i després, no botons d'un formulari: van plans, com a /docs. */
.docs-pager-link {
flex: 1 1 0;
min-width: 0;
margin: 0;
padding: 10px 12px;
border: 1px solid var(--color-border);
border-radius: 8px;
box-shadow: none;
text-align: left;
color: var(--color-text);
}
.docs-pager-link.next {
text-align: right;
}
.docs-pager-label {
display: block;
font-size: 0.78rem;
letter-spacing: 0.06em;
text-transform: uppercase;
color: var(--color-gray);
}
</style>

View File

@@ -76,7 +76,6 @@ 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>
@@ -146,24 +145,6 @@ 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

@@ -0,0 +1,57 @@
<script setup>
import { computed, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, Top } from '@/services/Windows';
import { getBaseUrl } from '~/services/Server';
import WindowHandle from './partials/WindowHandle.vue';
// One media file of the note tree, shown in a window of its own: an image fills it, a sound and a
// video play in it, and anything else (a PDF, a document) is offered as a link to open.
const props = defineProps(['data']);
const id = props.data.id;
const media = props.data.media;
const handle = ref(null);
const wrapper = ref(null);
const url = computed(() => media?.file ? `${getBaseUrl()}/public/${media.file}` : '');
const kind = computed(() => {
const type = media?.mimeType ?? '';
if (type.startsWith('image/')) return 'image';
if (type.startsWith('audio/')) return 'audio';
if (type.startsWith('video/')) return 'video';
return 'file';
});
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, {
width: Math.max(420, Math.min(900, window.innerWidth - 24)),
height: Math.max(320, Math.min(700, window.innerHeight - 32))
});
ResetPosition(id, 'center');
});
</script>
<template>
<div class="window-wrapper media-window" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle" />
<div class="media-body">
<img v-if="kind === 'image'" class="media-image" :src="url" :alt="media?.name">
<audio v-else-if="kind === 'audio'" :src="url" controls></audio>
<video v-else-if="kind === 'video'" :src="url" controls></video>
<a v-else class="media-file" :href="url" target="_blank" rel="noopener">{{ media?.name }}</a>
</div>
</div>
</template>
<style scoped>
.media-window { min-width: 320px; min-height: 0; }
.media-body {
flex: 1; min-height: 0; box-sizing: border-box; padding: 10px;
display: flex; align-items: center; justify-content: center; overflow: auto;
}
.media-image { max-width: 100%; max-height: 100%; object-fit: contain; }
audio, video { max-width: 100%; }
.media-file { color: var(--color-link); word-break: break-word; }
</style>

View File

@@ -1,6 +1,6 @@
<script setup> <script setup>
import { onBeforeUnmount, onMounted, ref } from 'vue'; import { onBeforeUnmount, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, ClearWindow } 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 from '~/services/Server'; import Server from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -18,6 +18,7 @@ const creating = !!data.name;
onMounted(() => { onMounted(() => {
newName.value = data.name || ''; newName.value = data.name || '';
Top(wrapper);
SetupHandle(id, handle); SetupHandle(id, handle);
SetSize(id, { width: 420, height: 200 }); SetSize(id, { width: 420, height: 200 });
ResetPosition(id, 'center'); ResetPosition(id, 'center');

View File

@@ -1,6 +1,6 @@
<script setup> <script setup>
import { onBeforeUnmount, onMounted, ref } from 'vue'; import { onBeforeUnmount, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, ClearWindow } 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 from '~/services/Server'; import Server from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -17,6 +17,7 @@ const newName = ref('');
onMounted(() => { onMounted(() => {
newName.value = data.title || ''; newName.value = data.title || '';
Top(wrapper);
SetupHandle(id, handle); SetupHandle(id, handle);
SetSize(id, { width: 420, height: 200 }); SetSize(id, { width: 420, height: 200 });
ResetPosition(id, 'center'); ResetPosition(id, 'center');

View File

@@ -0,0 +1,57 @@
<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

@@ -28,6 +28,20 @@ what matters.
Deleting a folder does not delete your notes: the notes it held move up to its parent folder, its Deleting a folder does not delete your notes: the notes it held move up to its parent folder, its
sub-folders move up with them, and only the empty folders go away. sub-folders move up with them, and only the empty folders go away.
## Images and media
The notes sidebar lists media files as well as notes. Upload them with the picture button in the
notes header: images, sounds, videos and PDFs all work, and each row leads with an icon of its type,
the way a file explorer does. Clicking a row opens the file in a window of its own, and a media row
moves into a folder like a note — drag it there, or use **Move to Folder…** in its right-click menu.
Right-clicking a media row also deletes it, file included.
A note can point at an uploaded file by its name, the same way it links to the rest of the campaign.
Write `![[harbour.png]]` and an image is drawn in the note at that spot — the picture fills the note's
width. A sound, a video or a PDF written this way is shown as a link to the file. Without the **!** the
file's name is a normal link that opens the media window when clicked: `[[harbour.png]]`. Typing `[[`
while editing offers the uploaded files in the same menu as notes, characters, items and maps.
## Markdown ## Markdown
Headings, **bold**, *italic*, lists, quotes, tables, code and links all work: Headings, **bold**, *italic*, lists, quotes, tables, code and links all work:
@@ -46,6 +60,35 @@ 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. An uploaded image can be embedded the same way (`![[harbour.png]]`,
see [Images and media](#images-and-media)). 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
@@ -57,6 +100,11 @@ 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

View File

@@ -1,8 +1,8 @@
# Characters and items # Characters and items
The **Actors & Characters** and **Items** sections of the sidebar hold the people and things of a The **Actors & Characters** and **Items** sections of the sidebar hold the people and things of a
campaign as entries of their own, with a sheet each. They can be written by hand, and they are also campaign as entries of their own, with a sheet each. They can be written by hand, and the actors and
what a linked [Foundry VTT](/docs/foundry) world keeps itself in step with. items of a linked [Foundry VTT](/docs/foundry) world are sent into them.
## Actors ## Actors

View File

@@ -27,8 +27,7 @@ What a service may do is decided by the campaign you pick, so check the name bef
screen tells you which service is asking, and what it wants: screen tells you which service is asking, and what it wants:
- a **Discord server** reads the campaign's characters, so whoever is in that server can read them, - a **Discord server** reads the campaign's characters, so whoever is in that server can read them,
- a **Foundry world** keeps its actors and items in step with the campaign, which means it writes into - a **Foundry world** sends its actors and items into the campaign,
it, and Dragonroll writes into it,
- **Obsidian** reads the campaign's notes and pushes the ones you tell it to. - **Obsidian** reads the campaign's notes and pushes the ones you tell it to.
A campaign holds one link per service: linking a second Foundry world, or a second Discord server, A campaign holds one link per service: linking a second Foundry world, or a second Discord server,

View File

@@ -1,8 +1,8 @@
# Foundry VTT # Foundry VTT
The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's
characters and item directory arrive in the campaign, and what you change in Dragonroll goes back to characters and item directory arrive in the campaign. Sync runs one way only — from Foundry to
the world. Dragonroll — so nothing you change in the campaign is written back into the world.
There are two separate parts, and you only need the first of them: There are two separate parts, and you only need the first of them:
@@ -15,9 +15,15 @@ Character and item sync works without the bridge.
## Installing the module ## Installing the module
Foundry VTT v12 to v14. Copy the `dragonroll-foundry` folder into Foundry VTT v12 to v14. In Foundry's **Setup → Add-on Modules → Install Module**, paste the
`{Foundry user data}/Data/modules/dragonroll-foundry/`, restart Foundry, and enable **Dragonroll manifest URL `https://dragonroll.aranroig.com/foundry/module.json`. Foundry downloads the module
Foundry API** in the world's module settings. from your Dragonroll server, and the same URL later tells it when an update is available.
A self-hosted Dragonroll serves its own manifest at `https://<your-dragonroll-host>/foundry/module.json`.
Then enable **Dragonroll Foundry API** in the world's module settings. To install by hand instead,
copy the `dragonroll-foundry` folder into `{Foundry user data}/Data/modules/dragonroll-foundry/`
and restart Foundry.
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
@@ -50,7 +56,7 @@ Worth knowing:
| Character, NPC and creature actors | Actors with the same sheet: abilities, saving throws, skills, combat stats, proficiencies, tools, languages, traits, spells, carried gear with its icons, coins, portrait | | Character, NPC and creature actors | Actors with the same sheet: abilities, saving throws, skills, combat stats, proficiencies, tools, languages, traits, spells, carried gear with its icons, coins, portrait |
| The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description | | The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description |
| The folders grouping that item directory | Item folders with the same names and nesting | | 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 |
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
@@ -62,18 +68,18 @@ An actor or item keeps the Dragonroll id it was given in a `dragonroll-foundry.a
item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of
doubled, and renaming it in either place does not resurrect a duplicate. doubled, and renaming it in either place does not resurrect a duplicate.
Changes flow both ways as they happen, and Dragonroll's own edits are applied back in Foundry within a Changes flow one way: as you create, change or delete actors and world items in Foundry, they reach
few seconds. A **full** snapshot — the one taken when the world links, or forced from the actor the campaign. Nothing is written back, so editing a character, an item, a map or a note in Dragonroll
directory — is the only thing that prunes: it is the only moment either side can see the whole list and leaves the world alone. A **full** snapshot — the one taken when the world links, or forced from the
notice what is gone. Live edits never delete anything. actor directory — is the only thing that prunes: it is the only moment the campaign can see the whole
list and notice what is gone. Live edits never delete anything.
## Auto-sync, and sending one actor on purpose ## Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or **Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or
delete are sent to the campaign, and both sides reconcile every few seconds. Turning it off stops all delete are sent to the campaign. Turning it off stops all of it — nothing is sent, and the campaign
of it — nothing is sent, and Dragonroll stops rewriting your Foundry documents, so the campaign keeps keeps whatever it already holds. Turn it back on and the world's current state is sent again, including
whatever it already holds. Turn it back on and both sides reconcile again, including the edits queued the edits queued while it was off.
while it was off.
To send one character across right now, or to cross over while autosync is off, right-click the actor To send one character across right now, or to cross over while autosync is off, right-click the actor
(or several) in the Foundry actor directory and pick **Dragonroll: Force Sync**. Those actors, with the (or several) in the Foundry actor directory and pick **Dragonroll: Force Sync**. Those actors, with the

View File

@@ -0,0 +1,111 @@
// The rules behind the note editor's wiki-link autocomplete (type `[[` while editing a note and the
// campaign's notes, actors, items, maps and uploaded files 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 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, media } = {}) {
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);
push('media', media, (file) => file.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

@@ -0,0 +1,72 @@
// 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 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' },
media: { path: '/media/list', key: 'media' }
};
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: [], media: [] });
}
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, media]) => ({ notes, actors, items, maps, media }));
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,6 +88,32 @@ 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",
@@ -108,16 +134,32 @@ const linkExtension = {
}, },
renderer(token) { renderer(token) {
return `<span class="vue-link" data-href="${escapeAttr(token.link)}">Link</span>`; // The link shows the entry's name, not a generic "Link", so a note reads as written. The
// note looks the target up by this label and turns the span into a preview link.
const label = String(token.link ?? "").trim() || token.link;
return `<span class="vue-link" data-href="${escapeAttr(token.link)}" role="link" tabindex="0">${escapeAttr(label)}</span>`;
}, },
}; };
marker.use({ marker.use({
extensions: [extension, inlineExtension, linkExtension], // The embed comes before the link: at the `!` of `![[…]]` the embed tokenizer is offered first,
// so the same label written with the bang does not fall through to the plain link.
extensions: [extension, inlineExtension, embedExtension, linkExtension],
}); });
function ParseMarkdown(source) { function ParseMarkdown(source) {
return marker.parse(source || ""); return marker.parse(source || "");
} }
export { ParseMarkdown, GetWidget }; // The widgets a note can use, as `{ inline: [...names], display: [...names] }`. The note editor's
// `@` autocomplete reads this, so a widget added to `widget_map` is offered there without any other
// change.
const GetWidgetRegistry = () => {
const registry = {};
for (const type of Object.keys(widget_map)) {
registry[type] = Object.keys(widget_map[type]);
}
return registry;
};
export { ParseMarkdown, GetWidget, GetWidgetRegistry };

View File

@@ -0,0 +1,78 @@
// 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,6 +82,12 @@ 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'),
@@ -120,6 +126,18 @@ const defWindows = {
component: () => import('~/components/windows/PinnedNoteWindow.vue'), component: () => import('~/components/windows/PinnedNoteWindow.vue'),
close: () => ClearWindow({type: 'pinned_note'}), close: () => ClearWindow({type: 'pinned_note'}),
movable: true movable: true
},
media_viewer: {
title: 'windows.media-viewer',
component: () => import('~/components/windows/MediaViewerWindow.vue'),
close: () => ClearWindow({type: 'media_viewer'}),
movable: true
},
documentation: {
title: 'windows.documentation',
component: () => import('~/components/windows/DocumentationWindow.vue'),
close: () => ClearWindow({type: 'documentation'}),
movable: true
} }
} }

View File

@@ -13,7 +13,6 @@
"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.",
@@ -38,7 +37,7 @@
}, },
"sidebar-label": "Campanya", "sidebar-label": "Campanya",
"synced": "Sincronitzat", "synced": "Sincronitzat",
"sections": { "notes": "Notes", "actors": "Actors i personatges", "items": "Objectes", "maps": "Mapes" }, "sections": { "notes": "Notes", "actors": "Actors i personatges", "items": "Objectes", "maps": "Mapes", "media": "Fitxers" },
"actions": { "actions": {
"new-note": "Nota nova", "new-folder": "Carpeta nova", "refresh": "Actualitza", "new-note": "Nota nova", "new-folder": "Carpeta nova", "refresh": "Actualitza",
"create": "Crea {section}", "submit": "Crea", "edit": "Edita", "save": "Desa", "delete": "Suprimeix", "saving": "Desant...", "create": "Crea {section}", "submit": "Crea", "edit": "Edita", "save": "Desa", "delete": "Suprimeix", "saving": "Desant...",
@@ -59,6 +58,7 @@
"empty-actors": "Encara no hi ha actors ni personatges.", "empty-items": "Encara no hi ha objectes en aquesta campanya.", "empty-actors": "Encara no hi ha actors ni personatges.", "empty-items": "Encara no hi ha objectes en aquesta campanya.",
"empty-maps": "Encara no hi ha mapes en aquesta campanya." "empty-maps": "Encara no hi ha mapes en aquesta campanya."
}, },
"media": { "upload": "Puja un fitxer multimèdia", "upload-error": "No s'ha pogut pujar aquest fitxer." },
"errors": { "load": "No s'han pogut carregar les entrades de la campanya." }, "errors": { "load": "No s'han pogut carregar les entrades de la campanya." },
"create-entry": "Crea una entrada de campanya", "create-entry": "Crea una entrada de campanya",
"fields": { "name": "Nom", "description": "Descripció" }, "fields": { "name": "Nom", "description": "Descripció" },
@@ -69,7 +69,7 @@
"types": { "character": "Personatge", "npc": "PNJ", "creature": "Criatura" } "types": { "character": "Personatge", "npc": "PNJ", "creature": "Criatura" }
}, },
"item": { "item": {
"new": "Objecte nou", "edit": "Edita l'objecte", "foundry-sync-note": "Els canvis en aquest objecte també s'apliquen al món del Foundry vinculat.", "new": "Objecte nou", "edit": "Edita l'objecte",
"category": "Categoria", "rarity": "Raresa", "category": "Categoria", "rarity": "Raresa",
"weight": "Pes (lb)", "properties": "Propietats", "properties-placeholder": "Per exemple, versàtil, subtil", "weight": "Pes (lb)", "properties": "Propietats", "properties-placeholder": "Per exemple, versàtil, subtil",
"sheet": { "sheet": {
@@ -113,6 +113,13 @@
"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

@@ -2,8 +2,6 @@
"errors": { "errors": {
"link-expired": "El codi d'enllaç de Foundry no és vàlid, ha caducat o ja s'ha utilitzat.", "link-expired": "El codi d'enllaç de Foundry no és vàlid, ha caducat o ja s'ha utilitzat.",
"world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.", "world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.",
"actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.",
"item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry.",
"icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.", "icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.",
"icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.", "icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.",
"import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.", "import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.",

View File

@@ -3,5 +3,9 @@
"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

@@ -10,7 +10,10 @@
"create-map": "Crear mapa", "create-map": "Crear mapa",
"map-viewer": "Mapa", "map-viewer": "Mapa",
"pinned-note": "Nota fixada", "pinned-note": "Nota fixada",
"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",
"media-viewer": "Multimèdia"
} }

View File

@@ -17,7 +17,6 @@
"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.",
@@ -42,7 +41,7 @@
}, },
"sidebar-label": "Campaign", "sidebar-label": "Campaign",
"synced": "Synced", "synced": "Synced",
"sections": { "notes": "Notes", "actors": "Actors & Characters", "items": "Items", "maps": "Maps" }, "sections": { "notes": "Notes", "actors": "Actors & Characters", "items": "Items", "maps": "Maps", "media": "Media" },
"actions": { "actions": {
"new-note": "New note", "new-folder": "New folder", "refresh": "Refresh", "new-note": "New note", "new-folder": "New folder", "refresh": "Refresh",
"create": "Create {section}", "submit": "Create", "edit": "Edit", "save": "Save", "delete": "Delete", "saving": "Saving...", "create": "Create {section}", "submit": "Create", "edit": "Edit", "save": "Save", "delete": "Delete", "saving": "Saving...",
@@ -63,6 +62,7 @@
"empty-actors": "No actors or characters yet.", "empty-items": "No items in this campaign yet.", "empty-actors": "No actors or characters yet.", "empty-items": "No items in this campaign yet.",
"empty-maps": "No maps in this campaign yet." "empty-maps": "No maps in this campaign yet."
}, },
"media": { "upload": "Upload media", "upload-error": "Unable to upload this file." },
"errors": { "load": "Unable to load campaign entries." }, "errors": { "load": "Unable to load campaign entries." },
"create-entry": "Create campaign entry", "create-entry": "Create campaign entry",
"fields": { "name": "Name", "description": "Description" }, "fields": { "name": "Name", "description": "Description" },
@@ -73,7 +73,7 @@
"types": { "character": "Character", "npc": "NPC", "creature": "Creature" } "types": { "character": "Character", "npc": "NPC", "creature": "Creature" }
}, },
"item": { "item": {
"new": "New item", "edit": "Edit item", "foundry-sync-note": "Changes to this item are also applied in the linked Foundry world.", "new": "New item", "edit": "Edit item",
"category": "Category", "rarity": "Rarity", "category": "Category", "rarity": "Rarity",
"weight": "Weight (lb)", "properties": "Properties", "properties-placeholder": "For example, versatile, finesse", "weight": "Weight (lb)", "properties": "Properties", "properties-placeholder": "For example, versatile, finesse",
"sheet": { "sheet": {
@@ -117,6 +117,13 @@
"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

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

View File

@@ -10,5 +10,9 @@
"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

@@ -10,7 +10,10 @@
"create-map": "Create Map", "create-map": "Create Map",
"map-viewer": "Map", "map-viewer": "Map",
"pinned-note": "Pinned note", "pinned-note": "Pinned note",
"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",
"media-viewer": "Media"
} }

View File

@@ -13,7 +13,6 @@
"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.",
@@ -38,7 +37,7 @@
}, },
"sidebar-label": "Campaña", "sidebar-label": "Campaña",
"synced": "Sincronizado", "synced": "Sincronizado",
"sections": { "notes": "Notas", "actors": "Actores y personajes", "items": "Objetos", "maps": "Mapas" }, "sections": { "notes": "Notas", "actors": "Actores y personajes", "items": "Objetos", "maps": "Mapas", "media": "Archivos" },
"actions": { "actions": {
"new-note": "Nueva nota", "new-folder": "Nueva carpeta", "refresh": "Actualizar", "new-note": "Nueva nota", "new-folder": "Nueva carpeta", "refresh": "Actualizar",
"create": "Crear {section}", "submit": "Crear", "edit": "Editar", "save": "Guardar", "delete": "Eliminar", "saving": "Guardando...", "create": "Crear {section}", "submit": "Crear", "edit": "Editar", "save": "Guardar", "delete": "Eliminar", "saving": "Guardando...",
@@ -59,6 +58,7 @@
"empty-actors": "Aún no hay actores ni personajes.", "empty-items": "Aún no hay objetos en esta campaña.", "empty-actors": "Aún no hay actores ni personajes.", "empty-items": "Aún no hay objetos en esta campaña.",
"empty-maps": "Aún no hay mapas en esta campaña." "empty-maps": "Aún no hay mapas en esta campaña."
}, },
"media": { "upload": "Subir archivo multimedia", "upload-error": "No se ha podido subir este archivo." },
"errors": { "load": "No se pudieron cargar las entradas de la campaña." }, "errors": { "load": "No se pudieron cargar las entradas de la campaña." },
"create-entry": "Crear entrada de campaña", "create-entry": "Crear entrada de campaña",
"fields": { "name": "Nombre", "description": "Descripción" }, "fields": { "name": "Nombre", "description": "Descripción" },
@@ -69,7 +69,7 @@
"types": { "character": "Personaje", "npc": "PNJ", "creature": "Criatura" } "types": { "character": "Personaje", "npc": "PNJ", "creature": "Criatura" }
}, },
"item": { "item": {
"new": "Nuevo objeto", "edit": "Editar objeto", "foundry-sync-note": "Los cambios en este objeto también se aplican al mundo de Foundry vinculado.", "new": "Nuevo objeto", "edit": "Editar objeto",
"category": "Categoría", "rarity": "Rareza", "category": "Categoría", "rarity": "Rareza",
"weight": "Peso (lb)", "properties": "Propiedades", "properties-placeholder": "Por ejemplo, versátil, sutil", "weight": "Peso (lb)", "properties": "Propiedades", "properties-placeholder": "Por ejemplo, versátil, sutil",
"sheet": { "sheet": {
@@ -113,6 +113,13 @@
"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

@@ -2,8 +2,6 @@
"errors": { "errors": {
"link-expired": "El código de vinculación de Foundry no es válido, ha caducado o ya se ha usado.", "link-expired": "El código de vinculación de Foundry no es válido, ha caducado o ya se ha usado.",
"world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.", "world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.",
"actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.",
"item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry.",
"icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.", "icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.",
"icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.", "icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.",
"import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.", "import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.",

View File

@@ -3,5 +3,9 @@
"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

@@ -10,7 +10,10 @@
"create-map": "Crear mapa", "create-map": "Crear mapa",
"map-viewer": "Mapa", "map-viewer": "Mapa",
"pinned-note": "Nota fijada", "pinned-note": "Nota fijada",
"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",
"media-viewer": "Multimedia"
} }

View File

@@ -0,0 +1,7 @@
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

@@ -0,0 +1,14 @@
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

@@ -0,0 +1,110 @@
// 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

@@ -0,0 +1,51 @@
# Dragonroll Sync for Obsidian
An Obsidian community plugin that imports notes from a Dragonroll campaign and pushes the active
Markdown note back to Dragonroll.
## Install from this repository
Copy `main.js` and `manifest.json` into:
```text
<vault>/.obsidian/plugins/dragonroll-sync/
```
Then enable **Dragonroll Sync** in Obsidian's Community Plugins settings. The plugin is plain
JavaScript and does not need a build step.
## Connect your account
Open **Settings → Community plugins → Dragonroll Sync**, enter the Dragonroll API URL and sign in
with your Dragonroll username/email and password. The default API URL is
`https://dragonroll.aranroig.com/api`; a local server can use `http://localhost:5000/api`.
Choose a campaign after signing in. The plugin saves the Dragonroll session token in this vault;
Dragonroll sessions expire after 48 hours. The password is not saved.
## Commands
- **Import or refresh campaign notes** fetches all campaign notes, including notes inside nested
Dragonroll folders, into `Dragonroll/<Campaign>/`. Imported notes keep their folder hierarchy.
- **Push active note to Dragonroll** creates the active Markdown note as a root campaign note, or
updates its linked Dragonroll note. A note linked to a different campaign cannot be pushed while
another campaign is selected.
The import command adds `dragonrollId`, `dragonrollCampaign`, and `dragonrollTitle` properties to
each imported note's frontmatter. These properties link the local file to its remote record and are
omitted from the Markdown content sent back to Dragonroll. Pushing a new local note adds those
properties as well.
## Automatic sync
Turn on **Auto-sync changes** in the plugin settings and the plugin follows the vault instead of
waiting for the commands: saving an edited note updates its Dragonroll note, a new note created
inside `Dragonroll/<Campaign>/` becomes a campaign note, and deleting a linked file deletes its
Dragonroll note (deleting a folder takes the notes under it along). Notes that are not linked to the
selected campaign are never touched, and the toggle is off by default.
Import protects local edits. It updates a linked note only when the local copy still matches the
last imported/pushed version. If the local copy changed, or both copies changed since the last sync,
the plugin keeps the local file and reports it for review. Push is explicit and updates Dragonroll
with the active note's current title and content.
Without automatic sync this is an explicit import/push workflow; it does not delete notes.

View File

@@ -0,0 +1,647 @@
const {
Notice,
Plugin,
PluginSettingTab,
Setting,
normalizePath,
requestUrl,
} = require('obsidian');
const DEFAULT_SETTINGS = {
apiBaseUrl: 'https://dragonroll.aranroig.com/api',
token: '',
campaignId: '',
autoSync: false,
snapshots: {},
};
const NOTE_ID_PROPERTY = 'dragonrollId';
const CAMPAIGN_PROPERTY = 'dragonrollCampaign';
const REMOTE_TITLE_PROPERTY = 'dragonrollTitle';
module.exports = class DragonrollSyncPlugin extends Plugin {
async onload() {
await this.loadSettings();
this.status = this.addStatusBarItem();
this.updateStatus();
this.addRibbonIcon('refresh-cw', 'Import Dragonroll campaign notes', () => this.importCampaignNotes());
this.addCommand({
id: 'import-campaign-notes',
name: 'Import or refresh campaign notes',
callback: () => this.importCampaignNotes(),
});
this.addCommand({
id: 'push-active-note',
name: 'Push active note to Dragonroll',
checkCallback: (checking) => {
const file = this.app.workspace.getActiveFile();
if (!file || file.extension !== 'md') return false;
if (!checking) void this.pushActiveNote();
return true;
},
});
this.addSettingTab(new DragonrollSettingTab(this.app, this));
this.suspended = false;
this.internalWrites = new Set();
this.linkedNotes = new Map();
this.syncChain = Promise.resolve();
this.app.workspace.onLayoutReady(() => this.refreshLinkedNotes());
this.registerEvent(this.app.vault.on('modify', (file) => this.onVaultChange(file)));
this.registerEvent(this.app.vault.on('create', (file) => this.onVaultChange(file)));
this.registerEvent(this.app.vault.on('rename', (file, oldPath) => this.onVaultChange(file, oldPath)));
this.registerEvent(this.app.vault.on('delete', (file) => this.onVaultDelete(file)));
if (this.settings.token && this.settings.campaignId) {
this.status.setText('Dragonroll: ready');
}
}
async loadSettings() {
this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
if (!this.settings.snapshots || typeof this.settings.snapshots !== 'object') {
this.settings.snapshots = {};
}
}
async saveSettings() {
await this.saveData(this.settings);
this.updateStatus();
}
updateStatus() {
if (!this.status) return;
if (!this.settings.token) this.status.setText('Dragonroll: signed out');
else if (!this.settings.campaignId) this.status.setText('Dragonroll: choose campaign');
else this.status.setText('Dragonroll: ready');
}
apiBaseUrl() {
let url = String(this.settings.apiBaseUrl || '').trim().replace(/\/+$/, '');
if (!url) throw new Error('Enter the Dragonroll API URL in settings.');
if (!/\/api$/i.test(url)) url += '/api';
return url;
}
async request(path, { method = 'GET', body, authenticated = true } = {}) {
const headers = { Accept: 'application/json' };
if (authenticated && this.settings.token) {
headers.Authorization = `Bearer ${this.settings.token}`;
}
if (body !== undefined) headers['Content-Type'] = 'application/json';
let response;
try {
response = await requestUrl({
url: `${this.apiBaseUrl()}${path}`,
method,
headers,
body: body === undefined ? undefined : JSON.stringify(body),
throw: false,
});
} catch (error) {
throw new Error(`Could not reach Dragonroll: ${error.message || error}`);
}
let data;
try {
data = response.json;
} catch {
throw new Error(`Dragonroll returned an unreadable response (HTTP ${response.status}).`);
}
if (response.status < 200 || response.status >= 300 || data?.status !== 'ok') {
const message = data?.msg || `HTTP ${response.status}`;
if (response.status === 401 || message === 'unauthorized') {
throw new Error('Dragonroll rejected this session. Sign in again in plugin settings.');
}
throw new Error(`Dragonroll: ${message}`);
}
return data;
}
async login(usermail, password) {
const data = await this.request('/user/login', {
method: 'POST',
body: { usermail, password },
authenticated: false,
});
this.settings.token = data.token;
this.settings.campaignId = '';
await this.saveSettings();
return this.getCampaigns();
}
async getCampaigns() {
const data = await this.request('/campaign/list');
return data.campaigns || [];
}
async selectedCampaign() {
if (!this.settings.token) throw new Error('Sign in to Dragonroll in plugin settings first.');
if (!this.settings.campaignId) throw new Error('Choose a campaign in plugin settings first.');
const campaigns = await this.getCampaigns();
const campaign = campaigns.find((item) => String(item._id) === String(this.settings.campaignId));
if (!campaign) throw new Error('The selected campaign is unavailable. Choose a campaign in settings.');
return campaign;
}
async fetchCampaignNotes(campaignId) {
const root = await this.request(`/note/list?campaign=${encodeURIComponent(campaignId)}`);
const folders = root.folders || [];
const folderById = new Map(folders.map((folder) => [String(folder._id), folder]));
const pathCache = new Map();
const folderPath = (folderId, visiting = new Set()) => {
const id = String(folderId || '');
if (!id || !folderById.has(id)) return [];
if (pathCache.has(id)) return pathCache.get(id);
if (visiting.has(id)) return [];
const folder = folderById.get(id);
const nextVisiting = new Set(visiting);
nextVisiting.add(id);
const parent = folder.parentFolder ? String(folder.parentFolder) : '';
const path = [...folderPath(parent, nextVisiting), safeSegment(folder.name, 'Folder')];
pathCache.set(id, path);
return path;
};
const nestedResults = await Promise.all(folders.map(async (folder) => {
const data = await this.request(
`/note/subfolder/list?campaign=${encodeURIComponent(campaignId)}&folder=${encodeURIComponent(folder._id)}`
);
return (data.notes || []).map((note) => ({ note, folders: folderPath(folder._id) }));
}));
const notes = (root.notes || []).map((note) => ({ note, folders: [] }));
for (const result of nestedResults) notes.push(...result);
return notes;
}
async importCampaignNotes() {
this.suspended = true;
try {
const campaign = await this.selectedCampaign();
const notes = await this.fetchCampaignNotes(campaign._id);
const existingById = await this.findFilesByDragonrollId();
const baseFolder = normalizePath(`Dragonroll/${safeSegment(campaign.name, 'Campaign')}`);
let created = 0;
let updated = 0;
let unchanged = 0;
let protectedNotes = 0;
for (const entry of notes) {
const remote = entry.note;
const id = String(remote._id);
const title = String(remote.title || 'Untitled');
const content = String(remote.content || '');
const remoteSignature = await signature(title, content);
const file = existingById.get(id);
if (!file) {
const targetFolder = normalizePath([baseFolder, ...entry.folders].join('/'));
await this.ensureFolder(targetFolder);
const path = await this.availableMarkdownPath(targetFolder, title, id);
const newFile = await this.app.vault.create(path, content);
await this.setNoteIdentity(newFile, id, campaign._id, title);
this.settings.snapshots[id] = remoteSignature;
this.linkedNotes.set(newFile.path, { noteId: id, campaignId: String(campaign._id) });
created += 1;
continue;
}
const localContent = await this.app.vault.read(file);
const frontmatter = this.app.metadataCache.getFileCache(file)?.frontmatter || {};
const storedTitle = frontmatter[REMOTE_TITLE_PROPERTY];
const localTitle = storedTitle && safeSegment(storedTitle, 'Untitled') === file.basename
? String(storedTitle)
: file.basename;
const localSignature = await signature(localTitle, stripPluginMetadata(localContent));
const baseline = this.settings.snapshots[id];
if (!baseline) {
if (localSignature === remoteSignature) {
this.settings.snapshots[id] = remoteSignature;
unchanged += 1;
} else {
protectedNotes += 1;
}
continue;
}
const localChanged = localSignature !== baseline;
const remoteChanged = remoteSignature !== baseline;
if (localChanged && remoteChanged) {
protectedNotes += 1;
continue;
}
if (localChanged) {
protectedNotes += 1;
continue;
}
if (!remoteChanged) {
unchanged += 1;
continue;
}
await this.app.vault.modify(file, content);
await this.setNoteIdentity(file, id, campaign._id, title);
const renamed = await this.renameImportedFile(file, title, id);
this.settings.snapshots[id] = remoteSignature;
updated += 1;
if (renamed) existingById.set(id, renamed);
this.linkedNotes.set((renamed || file).path, { noteId: id, campaignId: String(campaign._id) });
}
await this.saveSettings();
const details = protectedNotes ? `; ${protectedNotes} local edit(s) kept for review` : '';
new Notice(`Dragonroll import: ${created} added, ${updated} updated, ${unchanged} unchanged${details}.`);
} catch (error) {
new Notice(error.message || 'Could not import Dragonroll notes.');
} finally {
this.suspended = false;
}
}
async pushActiveNote() {
try {
const campaign = await this.selectedCampaign();
const file = this.app.workspace.getActiveFile();
if (!file || file.extension !== 'md') throw new Error('Open a Markdown note to push it.');
const cache = this.app.metadataCache.getFileCache(file);
const frontmatter = cache?.frontmatter || {};
const linkedCampaign = frontmatter[CAMPAIGN_PROPERTY];
const noteId = frontmatter[NOTE_ID_PROPERTY];
if (noteId && String(linkedCampaign || '') !== String(campaign._id)) {
throw new Error('This note is linked to another Dragonroll campaign. Select that campaign to push it.');
}
const markdown = stripPluginMetadata(await this.app.vault.read(file));
let remote;
if (noteId) {
const data = await this.request('/note/update', {
method: 'POST',
body: { id: String(noteId), title: file.basename, content: markdown },
});
remote = data.note;
} else {
const data = await this.request('/note/create', {
method: 'POST',
body: { title: file.basename, content: markdown, campaign: campaign._id },
});
remote = data.note;
}
const id = String(remote._id || noteId);
this.internalWrites.add(file.path);
try {
await this.setNoteIdentity(file, id, campaign._id, file.basename);
} finally {
this.internalWrites.delete(file.path);
}
this.settings.snapshots[id] = await signature(file.basename, markdown);
await this.saveSettings();
this.linkedNotes.set(file.path, { noteId: id, campaignId: String(campaign._id) });
new Notice(`Pushed “${file.basename}” to Dragonroll.`);
} catch (error) {
new Notice(error.message || 'Could not push this note to Dragonroll.');
}
}
onVaultChange(file, oldPath) {
if (!this.settings.autoSync) return;
if (this.suspended || this.internalWrites.has(file.path)) return;
if (file.extension !== 'md') return;
if (oldPath) this.linkedNotes.delete(oldPath);
this.queue(() => this.syncFile(file));
}
onVaultDelete(file) {
if (!this.settings.autoSync || this.suspended) return;
const ids = [];
for (const [path, linked] of this.linkedNotes) {
if (path !== file.path && !path.startsWith(`${file.path}/`)) continue;
this.linkedNotes.delete(path);
if (linked.campaignId === String(this.settings.campaignId)) ids.push(linked.noteId);
}
if (!ids.length) return;
this.queue(async () => {
for (const id of ids) delete this.settings.snapshots[id];
await this.saveSettings();
// Keep going past a note the campaign already dropped.
let failure;
for (const id of ids) {
try {
await this.request('/note/delete', { method: 'POST', body: { id } });
} catch (error) {
failure = failure || error;
}
}
if (failure) throw failure;
this.flashSynced();
});
}
queue(task) {
this.syncChain = this.syncChain
.then(task)
.then(() => { this.syncError = ''; })
.catch((error) => {
// An offline vault autosaves often: report a repeated failure once.
if (this.syncError === error.message) return;
this.syncError = error.message;
new Notice(error.message || 'Could not sync with Dragonroll.');
});
}
async syncFile(file) {
if (!this.settings.token || !this.settings.campaignId) return;
if (!this.app.vault.getAbstractFileByPath(file.path)) return;
const frontmatter = this.app.metadataCache.getFileCache(file)?.frontmatter || {};
const noteId = frontmatter[NOTE_ID_PROPERTY] ? String(frontmatter[NOTE_ID_PROPERTY]) : '';
const campaignId = String(frontmatter[CAMPAIGN_PROPERTY] || '');
if (noteId) {
this.linkedNotes.set(file.path, { noteId, campaignId });
if (campaignId && campaignId !== String(this.settings.campaignId)) return;
} else if (!file.path.startsWith('Dragonroll/')) {
return;
}
const markdown = stripPluginMetadata(await this.app.vault.read(file));
const title = file.basename;
const current = await signature(title, markdown);
if (noteId) {
if (this.settings.snapshots[noteId] === current) return;
await this.request('/note/update', {
method: 'POST',
body: { id: noteId, title, content: markdown },
});
this.settings.snapshots[noteId] = current;
await this.saveSettings();
this.flashSynced();
return;
}
// A new local file only becomes a campaign note inside the campaign's import folder.
const campaign = await this.selectedCampaign();
const folder = normalizePath(`Dragonroll/${safeSegment(campaign.name, 'Campaign')}`);
if (!file.path.startsWith(`${folder}/`)) return;
const data = await this.request('/note/create', {
method: 'POST',
body: { title, content: markdown, campaign: campaign._id },
});
const id = String(data.note._id);
this.settings.snapshots[id] = current;
await this.saveSettings();
this.internalWrites.add(file.path);
try {
await this.setNoteIdentity(file, id, campaign._id, title);
} finally {
this.internalWrites.delete(file.path);
}
this.linkedNotes.set(file.path, { noteId: id, campaignId: String(campaign._id) });
this.flashSynced();
}
refreshLinkedNotes() {
this.linkedNotes.clear();
for (const file of this.app.vault.getMarkdownFiles()) {
const frontmatter = this.app.metadataCache.getFileCache(file)?.frontmatter || {};
const noteId = frontmatter[NOTE_ID_PROPERTY];
if (!noteId) continue;
this.linkedNotes.set(file.path, {
noteId: String(noteId),
campaignId: String(frontmatter[CAMPAIGN_PROPERTY] || ''),
});
}
}
flashSynced() {
if (!this.status) return;
this.status.setText('Dragonroll: synced');
setTimeout(() => this.updateStatus(), 2000);
}
async findFilesByDragonrollId() {
const result = new Map();
for (const file of this.app.vault.getMarkdownFiles()) {
const frontmatter = this.app.metadataCache.getFileCache(file)?.frontmatter;
const id = frontmatter?.[NOTE_ID_PROPERTY];
if (id && !result.has(String(id))) result.set(String(id), file);
}
return result;
}
async setNoteIdentity(file, noteId, campaignId, title) {
await this.app.fileManager.processFrontMatter(file, (frontmatter) => {
frontmatter[NOTE_ID_PROPERTY] = String(noteId);
frontmatter[CAMPAIGN_PROPERTY] = String(campaignId);
frontmatter[REMOTE_TITLE_PROPERTY] = String(title || file.basename);
});
}
async ensureFolder(path) {
const normalized = normalizePath(path);
if (!normalized || normalized === '.') return;
const parts = normalized.split('/');
let current = '';
for (const part of parts) {
current = current ? `${current}/${part}` : part;
if (!this.app.vault.getAbstractFileByPath(current)) {
await this.app.vault.createFolder(current);
}
}
}
async availableMarkdownPath(folder, title, noteId) {
const base = safeSegment(title, 'Untitled');
let path = normalizePath(`${folder}/${base}.md`);
if (!this.app.vault.getAbstractFileByPath(path)) return path;
const suffix = String(noteId).slice(-6);
path = normalizePath(`${folder}/${base} (${suffix}).md`);
let counter = 2;
while (this.app.vault.getAbstractFileByPath(path)) {
path = normalizePath(`${folder}/${base} (${suffix}-${counter}).md`);
counter += 1;
}
return path;
}
async renameImportedFile(file, title, noteId) {
const parent = file.parent?.path || '';
const base = safeSegment(title, 'Untitled');
let targetPath = normalizePath(parent ? `${parent}/${base}.md` : `${base}.md`);
if (targetPath === file.path) return file;
if (this.app.vault.getAbstractFileByPath(targetPath)) {
targetPath = await this.availableMarkdownPath(parent || '.', title, noteId);
}
await this.app.fileManager.renameFile(file, targetPath);
return this.app.vault.getAbstractFileByPath(targetPath);
}
};
class DragonrollSettingTab extends PluginSettingTab {
constructor(app, plugin) {
super(app, plugin);
this.plugin = plugin;
this.campaigns = [];
this.loginName = '';
this.password = '';
}
display() {
const { containerEl } = this;
containerEl.empty();
containerEl.createEl('h2', { text: 'Dragonroll Sync' });
containerEl.createEl('p', {
text: 'Sign in with your Dragonroll account, choose a campaign, then use the import and push commands. Your password is used only to sign in; the 48-hour session token is stored in this vault.',
});
new Setting(containerEl)
.setName('Dragonroll API URL')
.setDesc('Use the server address, with or without /api.')
.addText((text) => text
.setPlaceholder('https://dragonroll.aranroig.com/api')
.setValue(this.plugin.settings.apiBaseUrl)
.onChange(async (value) => {
const previous = this.plugin.settings.apiBaseUrl.trim().replace(/\/+$/, '');
const next = value.trim().replace(/\/+$/, '');
if (previous !== next) {
this.plugin.settings.token = '';
this.plugin.settings.campaignId = '';
this.campaigns = [];
}
this.plugin.settings.apiBaseUrl = value.trim();
await this.plugin.saveSettings();
}));
new Setting(containerEl)
.setName('Username or email')
.addText((text) => text
.setPlaceholder('Dragonroll username or email')
.onChange((value) => { this.loginName = value.trim(); }));
new Setting(containerEl)
.setName('Password')
.addText((text) => {
text.inputEl.type = 'password';
text.inputEl.autocomplete = 'off';
text.onChange((value) => { this.password = value; });
});
new Setting(containerEl)
.setName(this.plugin.settings.token ? 'Session' : 'Sign in')
.setDesc(this.plugin.settings.token ? 'The stored session expires after 48 hours.' : 'Password is not saved by this plugin.')
.addButton((button) => button
.setButtonText('Sign in')
.setCta()
.onClick(async () => {
if (!this.loginName || !this.password) {
new Notice('Enter your Dragonroll username/email and password.');
return;
}
button.setDisabled(true);
try {
this.campaigns = await this.plugin.login(this.loginName, this.password);
this.password = '';
this.display();
new Notice(`Signed in. Found ${this.campaigns.length} campaign(s).`);
} catch (error) {
new Notice(error.message || 'Could not sign in to Dragonroll.');
} finally {
button.setDisabled(false);
}
}));
if (this.plugin.settings.token) {
new Setting(containerEl)
.setName('Campaign')
.setDesc('The campaign used by import and push commands.')
.addDropdown((dropdown) => {
dropdown.addOption('', 'Choose a campaign');
for (const campaign of this.campaigns) {
dropdown.addOption(String(campaign._id), campaign.name);
}
dropdown.setValue(this.plugin.settings.campaignId || '');
dropdown.onChange(async (value) => {
this.plugin.settings.campaignId = value;
await this.plugin.saveSettings();
});
})
.addButton((button) => button
.setButtonText('Load campaigns')
.onClick(async () => {
button.setDisabled(true);
try {
this.campaigns = await this.plugin.getCampaigns();
this.display();
new Notice(`Loaded ${this.campaigns.length} campaign(s).`);
} catch (error) {
new Notice(error.message || 'Could not load campaigns.');
} finally {
button.setDisabled(false);
}
}));
new Setting(containerEl)
.setName('Auto-sync changes')
.setDesc('Every time Obsidian saves a linked note, its title and content are sent to Dragonroll. A new note inside the campaign folder becomes a campaign note, and deleting a linked file deletes its campaign note. Off means only the import and push commands touch Dragonroll.')
.addToggle((toggle) => toggle
.setValue(!!this.plugin.settings.autoSync)
.onChange(async (value) => {
this.plugin.settings.autoSync = value;
await this.plugin.saveSettings();
}));
new Setting(containerEl)
.setName('Sign out')
.setDesc('Remove the saved Dragonroll session from this vault.')
.addButton((button) => button
.setButtonText('Sign out')
.onClick(async () => {
this.plugin.settings.token = '';
this.plugin.settings.campaignId = '';
await this.plugin.saveSettings();
this.display();
}));
}
}
}
function safeSegment(value, fallback) {
const safe = String(value || '')
.replace(/[\\\/:*?"<>|#^\[\]]/g, '-')
.replace(/[. ]+$/g, '')
.trim();
return safe || fallback;
}
function stripPluginMetadata(markdown) {
const text = String(markdown || '');
const match = text.match(/^(---\r?\n)([\s\S]*?)(\r?\n---(?:\r?\n|$))/);
if (!match) return text;
const keptLines = match[2].split(/\r?\n/).filter((line) =>
!/^(dragonrollId|dragonrollCampaign|dragonrollTitle):\s*/.test(line)
);
const frontmatter = keptLines.join('\n').trim();
const body = text.slice(match[0].length);
return frontmatter ? `---\n${frontmatter}\n---\n${body}` : body;
}
async function signature(title, content) {
const value = `${title}\u0000${String(content).replace(/\r\n/g, '\n')}`;
if (globalThis.crypto?.subtle) {
const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
}
let hash = 2166136261;
for (let index = 0; index < value.length; index += 1) {
hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
}
return (hash >>> 0).toString(16);
}

View File

@@ -0,0 +1,9 @@
{
"id": "dragonroll-sync",
"name": "Dragonroll Sync",
"version": "1.0.0",
"minAppVersion": "1.5.0",
"description": "Import Dragonroll campaign notes into Obsidian and push edits back.",
"author": "Dragonroll",
"isDesktopOnly": false
}

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 reach the campaign", () => { test("the world's own traits and features 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,12 +376,17 @@ test("the world's own traits reach the campaign", () => {
name: "Thalia", name: "Thalia",
system: {}, system: {},
items: [ items: [
{ name: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } }, { name: "Darkvision", type: "feat", img: "http://vtt.test/icons/eye.svg", system: { type: { value: "race" }, description: { value: "<p>See in the dark.</p>" } } },
{ name: "Brave", type: "feat", system: { featType: ["tr"], description: { value: "Advantage on saves." } } }, { name: "Second Wind", type: "feat", system: { type: { value: "class" }, description: { value: "Regain hit points." } } },
{ name: "Alert", type: "feat", system: { featType: "feat", description: { value: "Never surprised." } } }, { name: "Alert", type: "feat", system: { type: { value: "feat" }, description: { value: "Never surprised." } } },
], ],
}); });
assert.equal(fromFeatures.traits, "Darkvision\nSee in the dark.\n\nBrave\nAdvantage on saves."); assert.deepEqual(fromFeatures.features, [
{ name: "Darkvision", description: "See in the dark.", icon: "http://vtt.test/icons/eye.svg" },
{ name: "Second Wind", description: "Regain hit points.", icon: "" },
{ name: "Alert", description: "Never surprised.", icon: "" },
], "each feature is a row of its own, with the world's icon and text");
assert.ok(!("traits" in fromFeatures), "the feature items are not repeated as free text");
}); });
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", () => {
@@ -410,6 +415,50 @@ 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
// holds for that actor (Syndria98/dragonroll#96): the fields a live edit leaves out when
// the world says nothing are written empty instead of kept, and the campaign's own text
// on the actor's flag does not survive it.
test("a forced sync writes empty the fields a live edit would leave out", () => {
const actor = {
name: "Thalia",
system: {},
items: [],
flags: { [MODULE_ID]: { traits: "What the campaign typed", proficiencies: "Armour, tools" } },
};
const live = foundryActorToCharacter(actor);
assert.equal(live.traits, "What the campaign typed", "a live edit fills the traits tab from the actor's flag");
assert.equal(live.proficiencies, "Armour, tools", "and the free-text proficiencies from it too");
assert.ok(
!("tools" in live) && !("languages" in live) && !("skills" in live) && !("savingThrows" in live) && !("currency" in live),
"and says nothing about the toggles and lists the world has no data for"
);
const replaced = foundryActorToCharacter(actor, true);
assert.equal(replaced.traits, "", "a forced sync clears the traits the campaign typed");
assert.equal(replaced.proficiencies, "", "down to the free-text proficiencies");
assert.deepEqual(replaced.tools, []);
assert.deepEqual(replaced.languages, []);
assert.deepEqual(replaced.skills, {});
assert.deepEqual(replaced.savingThrows, {});
assert.deepEqual(replaced.currency, {});
});
// --- The module sends the names a sheet outside Foundry can read ----------------- // --- The module sends the names a sheet outside Foundry can read -----------------
function makeWorld({ actor, config = {}, worldItems = [] }) { function makeWorld({ actor, config = {}, worldItems = [] }) {

View File

@@ -51,7 +51,9 @@ 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.equal(character.traits, "Darkvision\nSee in the dark.", "the feat is read as a trait, where the sheet shows it"); assert.deepEqual(character.features,
[{ name: "Darkvision", description: "See in the dark.", icon: "" }],
"the feat stands as a feature row, where the sheet shows it");
assert.equal(character.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");
}); });
@@ -133,6 +135,8 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
}; };
const requireStub = (id) => { const requireStub = (id) => {
@@ -143,6 +147,7 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js")); if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/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/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`);
}; };
@@ -334,8 +339,6 @@ function makeWorld({ actors = [], remoteActors = [] } = {}) {
fetch: async (url, options = {}) => { fetch: async (url, options = {}) => {
const href = String(url); const href = String(url);
state.requests.push({ href, method: options.method, body: options.body ? JSON.parse(options.body) : null }); state.requests.push({ href, method: options.method, body: options.body ? JSON.parse(options.body) : null });
if (href.includes("foundry/sync/characters")) return { ok: true, status: 200, json: async () => ({ status: "ok", actors: remoteActors }) };
if (href.includes("foundry/sync/items")) return { ok: true, status: 200, json: async () => ({ status: "ok", items: [] }) };
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) }; return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
}, },
Item: { async create() { return null; } }, Item: { async create() { return null; } },
@@ -409,87 +412,6 @@ function makeWorld({ actors = [], remoteActors = [] } = {}) {
return state; return state;
} }
// The campaign's character for `actor`, holding what Dragonroll keeps for it.
function campaignCharacter(actor, over = {}) {
return {
_id: "dr-actor-1",
name: "Thalia",
type: "character",
species: "",
className: "",
subclass: "",
level: 1,
background: "",
challengeRating: "",
description: "",
image: "",
abilityScores: {},
armorClass: 10,
speed: 30,
traits: "",
proficiencies: "",
spells: "",
inventory: [],
foundryActorId: actor?.id ?? null,
...over,
};
}
test("a trait row an older campaign left in the inventory does not become a loot duplicate", async () => {
// A campaign that synced before #89 still carries its world's traits as inventory
// rows. Writing the character must neither make a piece of loot after a trait's name
// nor touch the world's feat it holds that name — the row is the campaign's to write
// off, and the document is the world's to keep.
const actor = makeStubActor("Thalia", {
system: { details: {} },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [{ _id: "feat-1", name: "Darkvision", type: "feat", system: { featType: "trs" } }],
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, {
traits: "Darkvision\nSee in the dark.",
inventory: [{ name: "Darkvision", quantity: 1, weight: 0 }],
})],
}).start();
assert.deepEqual(world.itemNames(actor), [["feat", "Darkvision"]],
"no gear made after the trait's name, and the feat stands where it was");
assert.equal(actor.items.contents[0].system.quantity, undefined, "the world's feat is not written as gear");
assert.deepEqual(world.logs, [], "applying the character did not warn");
});
test("writing the character leaves the world's trait and species documents where they stand", async () => {
// An earlier sync marked everything in the actor as its own. The campaign no longer
// carries traits and species in the inventory, so those marks must not cost the world
// its documents — while loot the campaign truly dropped still goes.
const actor = makeStubActor("Thalia", {
system: { details: {} },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [
{ _id: "feat-1", name: "Darkvision", type: "feat", flags: { [MODULE_ID]: { syncedItem: true } } },
{ _id: "race-1", name: "Human", type: "race", flags: { [MODULE_ID]: { syncedItem: true } } },
{ _id: "loot-old", name: "Torch", type: "loot", flags: { [MODULE_ID]: { syncedItem: true } } },
],
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, {
species: "Human",
traits: "Darkvision\nSee in the dark.",
inventory: [{ name: "Rations", quantity: 1, weight: 0.5 }],
})],
}).start();
assert.deepEqual(world.itemNames(actor), [
["feat", "Darkvision"],
["race", "Human"],
["loot", "Rations"],
], "the trait and the species survive, the carried gear follows the campaign");
assert.equal(actor.system.details.race, "race-1", "the species reference still resolves to the surviving item");
assert.deepEqual(world.logs, [], "applying the character did not warn");
});
test("the snapshot marks the carried gear and no longer the world's own documents", async () => { test("the snapshot marks the carried gear and no longer the world's own documents", async () => {
const actor = makeStubActor("Grimnir", { const actor = makeStubActor("Grimnir", {
system: { details: {} }, system: { details: {} },

View File

@@ -3,8 +3,10 @@
// numbered group, translations for the group's label, and no link pointing at a page that does not // numbered group, translations for the group's label, and no link pointing at a page that does not
// exist, (2) the page about an integration really documents what that integration offers, which is // exist, (2) the page about an integration really documents what that integration offers, which is
// checked against the sources that define it: the slash commands of discord-bot/src/commands.js and // checked against the sources that define it: the slash commands of discord-bot/src/commands.js and
// the commands the Obsidian plugin registers, and (3) the routes: /docs and /docs/<slug> render the // the commands the Obsidian plugin registers, (3) the routes: /docs and /docs/<slug> render the
// documentation and every other address still opens the window app. // documentation and every other address still opens the window app, and (4) inside a campaign the
// same documentation opens as a window of its own instead of a trip to /docs
// (Syndria98/dragonroll#95).
// //
// `frontend/app/services/DocsMarkdown.js` is the pure part of the docs (headings, slugs, titles) and // `frontend/app/services/DocsMarkdown.js` is the pure part of the docs (headings, slugs, titles) and
// is loaded straight from source, the way the other tests load the frontend services; it imports // is loaded straight from source, the way the other tests load the frontend services; it imports
@@ -328,39 +330,89 @@ test("the main menu points at the documentation", () => {
}); });
// Inside a campaign the documentation is reached from the top bar, on the left of the campaign // Inside a campaign the documentation is reached from the top bar, on the left of the campaign
// settings button (Syndria98/dragonroll#90). // settings button (Syndria98/dragonroll#90), and it opens as a window of its own in front of the
test("the campaign top bar points at the documentation", () => { // workspace rather than as a trip to /docs (Syndria98/dragonroll#95).
test("the campaign top bar opens the documentation as a window", () => {
const topBar = readRepoFile("frontend", "app", "components", "viewer", "TopBar.vue"); const topBar = readRepoFile("frontend", "app", "components", "viewer", "TopBar.vue");
const right = /<div class="right">([\s\S]*?)<\/div>/.exec(topBar)?.[1]; const right = /<div class="right">([\s\S]*?)<\/div>/.exec(topBar)?.[1];
assert.ok(right, "expected the top bar to have its buttons in a right-hand group"); assert.ok(right, "expected the top bar to have its buttons in a right-hand group");
assert.match(right, /href="\/docs"/, "the top bar has to link to /docs"); assert.match(right, /OpenDocumentation/, "the top bar has a button for the documentation");
assert.match(right, /main-menu\.documentation/, "under the same label the main menu uses"); assert.match(right, /main-menu\.documentation/, "under the same label the main menu uses");
assert.match(topBar, /CreateWindow\('documentation'\)/, "the button opens the documentation window");
// To the left of the settings button: the group is read left to right, so the link has to // To the left of the settings button: the group is read left to right, so the button has to
// come first in it. // come first in it.
const docsAt = right.indexOf('href="/docs"'); const docsAt = right.indexOf("OpenDocumentation");
const settingsAt = right.indexOf("OpenCampaignSettings"); const settingsAt = right.indexOf("OpenCampaignSettings");
assert.ok( assert.ok(
docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt, docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt,
"the documentation button sits on the left of the settings button" "the documentation button sits on the left of the settings button"
); );
// /docs is another page, and the open notes of the campaign live only in memory, so the link // The open notes of the campaign live only in memory, so nothing the top bar does may leave
// opens it somewhere that does not throw the campaign away. // the app: a window comes to the front, an address would take the campaign away with it.
assert.match(right, /target="_blank"/, "the campaign stays as it was behind the documentation"); assert.doesNotMatch(topBar, /href="\/docs"/, "the top bar does not send the campaign to /docs");
assert.match(right, /rel="[^"]*noopener/, "a tab the app does not control must not be able to reach it"); assert.doesNotMatch(topBar, /target="_blank"/, "…nor opens a tab out of it");
});
// The link is an `<a>` and the buttons are styled by element, so it carries its own look, in // The window the button opens (Syndria98/dragonroll#95): registered like every other window, and
// theme colours like everything else. // reading its pages without ever leaving the window it is drawn in.
const look = /\.docs-button\s*\{[^}]*\}/.exec(topBar)?.[0]; test("the documentation is registered as a window", () => {
assert.ok(look, "the documentation link has to look like the buttons next to it"); const definitions = readRepoFile("frontend", "app", "services", "WindowDefinitions.js");
for (const declaration of [ const definition = /\n\s*documentation:\s*\{([\s\S]*?)\n\s{2}\}/.exec(definitions);
"background-color: var\\(--color-button-background\\)", assert.ok(definition, "the documentation is not registered as a window");
"color: var\\(--color-text\\)",
"border: solid 1px var\\(--color-border\\)", assert.match(definition[1], /title:\s*'windows\.documentation'/, "its title is an i18n key");
]) { assert.match(definition[1], /movable:\s*true/);
assert.match(look, new RegExp(declaration), "the link's look uses the theme's colours"); assert.match(definition[1], /close:\s*\(\)\s*=>\s*ClearWindow\(\{\s*type:\s*'documentation'\s*\}\)/);
const component = /component:\s*\(\)\s*=>\s*import\(['"]~\/components\/windows\/([^'"]+)['"]\)/.exec(definition[1]);
assert.ok(component, "the documentation window names no component of its own");
assert.ok(
fs.existsSync(path.join(__dirname, "..", "frontend", "app", "components", "windows", component[1])),
`the documentation window points at a component that does not exist: ${component[1]}`
);
});
test("the documentation window reads the published pages without leaving itself", () => {
const source = readRepoFile("frontend", "app", "components", "windows", "DocumentationWindow.vue");
// The pages are the ones of app/content/docs, read through the same service the /docs page uses.
assert.match(source, /from '~\/services\/Docs'/, "the window reads the documentation through the docs service");
for (const lookup of ["GetDocsNav", "GetDocsPage", "GetDocsFirstSlug"]) {
assert.match(source, new RegExp(lookup), `the window does not use ${lookup}`);
}
// Resizable, with a floor low enough to read the two columns on a small screen.
assert.match(source, /SetResizable\(id,\s*true\)/, "the window is resizable");
assert.match(source, /SetMinSize\(id,\s*\{\s*width:\s*\d+,\s*height:\s*\d+\s*\}\)/, "…and it says how small it goes");
// Nothing in it is a route: the window holds the page it shows, so following the sidebar
// leaves the campaign behind it exactly as it was.
assert.doesNotMatch(source, /NuxtLink|useRoute|navigateTo/, "the documentation window does not navigate the app");
// Which means the links the markdown carries (`[Foundry](/docs/foundry)`) and the sections of
// a page have to be answered inside the window.
assert.match(source, /\\\/docs/, "the markdown's links to the other pages are followed in the window");
assert.match(source, /scrollIntoView/, "so are the sections of the page it is showing");
assert.match(source, /preventDefault/, "…and none of them reaches the app's address");
// A window is not a page: the reading column is what scrolls, nothing is as tall as the viewport.
const reading = /\.docs-reading\s*\{[^}]*\}/.exec(source)?.[0];
assert.ok(reading, "the window has a reading column of its own");
assert.match(reading, /overflow-y:\s*auto/, "…and that is what scrolls");
assert.doesNotMatch(source, /100vh/, "a window fills itself, not the viewport");
});
test("the documentation window is titled in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "windows.json"));
const title = strings.documentation;
assert.ok(title, `${locale} has no title for the documentation window`);
if (locale !== "en") {
assert.notEqual(title.toLowerCase(), "documentation", `the ${locale} window title is untranslated`);
}
} }
}); });
@@ -484,3 +536,29 @@ test("the sections aside has more room around its links than the sidebar has", (
"the sections aside asks for more padding than the two asides share" "the sections aside asks for more padding than the two asides share"
); );
}); });
// The /docs page and the documentation window render the very same HTML, so the markdown it renders
// is styled once, in the stylesheet both of them load, rather than in whichever one asked for it
// first (Syndria98/dragonroll#95).
test("the rendered markdown is styled once, where both readers reach it", () => {
const styles = readRepoFile("frontend", "app", "assets", "css", "main.scss");
const markdown = styles.slice(styles.indexOf(".docs-markdown h1"));
for (const selector of [
".docs-markdown h1",
".docs-markdown h2",
".docs-markdown h3",
".docs-markdown p",
".docs-markdown a",
".docs-markdown code",
".docs-markdown pre",
".docs-markdown table",
]) {
assert.ok(markdown.includes(selector), `${selector} has to be styled for both readers of the docs`);
}
// Theme colours, as everywhere: the window and the page are read on either theme.
for (const colour of ["var\\(--color-border\\)", "var\\(--color-link\\)", "var\\(--color-background-light\\)"]) {
assert.match(markdown, new RegExp(colour), "the markdown's look uses the theme's colours");
}
});

View File

@@ -173,6 +173,7 @@ function campaign({ folders = [], notes = [], actors = [], items = [], maps = []
// seed says otherwise. // seed says otherwise.
Folder: realFolderModel(folders.map((folder) => ({ campaign: "campaign-1", ...folder }))), Folder: realFolderModel(folders.map((folder) => ({ campaign: "campaign-1", ...folder }))),
Note: fakeCollection("note", notes), Note: fakeCollection("note", notes),
Media: fakeCollection("media", []),
Actor: fakeCollection("actor", actors), Actor: fakeCollection("actor", actors),
Item: fakeCollection("item", items), Item: fakeCollection("item", items),
Map: fakeCollection("map", maps), Map: fakeCollection("map", maps),
@@ -182,6 +183,7 @@ function campaign({ folders = [], notes = [], actors = [], items = [], maps = []
"../models/Campaign": { findOne: () => ({ lean: async () => campaignDoc }) }, "../models/Campaign": { findOne: () => ({ lean: async () => campaignDoc }) },
"../models/Folder": collections.Folder, "../models/Folder": collections.Folder,
"../models/Note": collections.Note, "../models/Note": collections.Note,
"../models/Media": collections.Media,
"../models/Actor": collections.Actor, "../models/Actor": collections.Actor,
"../models/Item": collections.Item, "../models/Item": collections.Item,
"../models/Map": collections.Map, "../models/Map": collections.Map,

View File

@@ -6,21 +6,14 @@
// background item that does not exist and a details reference resolving to nothing — // background item that does not exist and a details reference resolving to nothing —
// adding a background in Foundry then failed. // adding a background in Foundry then failed.
// //
// The backend mapper is plain CommonJS and is required directly. The Foundry module is // The backend mapper is plain CommonJS and is required directly: it reads the
// loaded into a `node:vm` context holding stubbed Foundry globals with fake timers, like // Foundry document and resolves those references to the names Dragonroll holds.
// tests/foundry-sync-toggle.test.js: the characters Dragonroll answers with are applied
// to a stubbed actor, so the references it writes are observable.
// //
// Run with `npm test` from the repository root, or `node --test tests/`. // Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test"); const { test } = require("node:test");
const assert = require("node:assert/strict"); const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path"); const path = require("node:path");
const vm = require("node:vm");
const MODULE_ID = "dragonroll-foundry";
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js")); const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js"));
@@ -91,327 +84,3 @@ test("a class reference that resolves to nothing falls back to the class item",
assert.equal(fields.className, "Fighter", "the class the actor carries, not the id"); assert.equal(fields.className, "Fighter", "the class the actor carries, not the id");
assert.equal(fields.species, "", "and nothing to name the species from"); assert.equal(fields.species, "", "and nothing to name the species from");
}); });
// --- The Foundry module applies Dragonroll's character --------------------------
// A reference is either the id this sync wrote or the document the field resolves to.
function referenceId(actor, field) {
const value = actor.system.details?.[field];
return typeof value === "string" ? value : value?._id || "";
}
function makeStubItem(id, { name, type, system = {}, flags = {} }) {
return {
_id: id,
id,
name,
type,
system,
flags,
parent: { documentName: "Actor" },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
toObject() {
return { _id: this.id, name: this.name, type: this.type, system: this.system, flags: this.flags };
},
};
}
function writeDotted(target, data) {
for (const [key, value] of Object.entries(data)) {
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
}
let stubCounter = 0;
function makeStubActor(name, { type = "character", system = {}, flags = {}, items = [] } = {}) {
stubCounter += 1;
const id = `actor-${stubCounter}`;
const contents = items.map((item, index) => makeStubItem(item._id || `embedded-${stubCounter}-${index}`, item));
const actor = {
id,
name,
type,
documentName: "Actor",
img: "icons/svg/mystery-man.svg",
system,
flags,
items: { contents },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(data) {
writeDotted(this, data);
return this;
},
async updateEmbeddedDocuments(documentName, updates) {
for (const update of updates) {
const item = contents.find((candidate) => candidate.id === update._id);
if (item) writeDotted(item, update);
}
return updates.map((update) => contents.find((candidate) => candidate.id === update._id));
},
async createEmbeddedDocuments(documentName, datas) {
const created = datas.map((data) => {
const item = makeStubItem(`embedded-${stubCounter}-${contents.length}`, data);
item.name = data.name;
item.type = data.type;
contents.push(item);
return item;
});
return created;
},
async deleteEmbeddedDocuments(documentName, ids) {
for (const id of ids) {
const index = contents.findIndex((item) => item.id === id);
if (index >= 0) contents.splice(index, 1);
}
return ids;
},
toObject() {
return {
_id: this.id,
name: this.name,
type: this.type,
img: this.img,
flags: this.flags,
system: this.system,
};
},
};
return actor;
}
// A linked world with the actors it holds, answering `foundry/sync/characters` with the
// campaign's characters. Each one is applied to its Foundry actor on the next reconcile.
function makeWorld({ actors = [], remoteActors = [] } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
nextTimerId: 1,
logs: [],
};
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: {
log() {},
info() {},
warn: (...args) => state.logs.push(args.map(String).join(" ")),
error: (...args) => state.logs.push(args.map(String).join(" ")),
},
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
ui: { notifications: { info() {}, warn() {}, error() {} } },
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); },
},
setTimeout: (fn, delay = 0) => {
const timerId = state.nextTimerId++;
state.timers.set(timerId, { fn, delay });
return timerId;
},
clearTimeout: (timerId) => state.timers.delete(timerId),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
const href = String(url);
state.requests.push({ href, method: options.method, body: options.body ? JSON.parse(options.body) : null });
if (href.includes("foundry/sync/characters")) return { ok: true, status: 200, json: async () => ({ status: "ok", actors: remoteActors }) };
if (href.includes("foundry/sync/items")) return { ok: true, status: 200, json: async () => ({ status: "ok", items: [] }) };
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Item: { async create() { return null; } },
Actor: {
async create(data) {
const actor = makeStubActor(data.name, {
type: data.type,
system: structuredClone(data.system || {}),
flags: structuredClone(data.flags || {}),
items: (data.items || []).map((item) => ({ name: item.name, type: item.type, system: item.system })),
});
actors.push(actor);
return actor;
},
},
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: actors, get: (actorId) => actors.find((actor) => actor.id === actorId) },
items: { contents: [], get: () => null },
folders: { contents: [], get: () => null },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.actor = (actorId) => actors.find((actor) => actor.id === actorId);
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
// World start: the actors are pushed, then the campaign's characters are applied.
state.start = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
return state;
};
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
state.itemNames = (actor) => actor.items.contents.map((item) => [item.type, item.name]);
return state;
}
// The campaign's character for `actor`, holding what Dragonroll keeps for it.
function campaignCharacter(actor, over = {}) {
return {
_id: "dr-actor-1",
name: "Thalia",
type: "character",
species: "",
className: "",
subclass: "",
level: 1,
background: "",
challengeRating: "",
description: "",
image: "",
abilityScores: {},
armorClass: 10,
speed: 30,
traits: "",
proficiencies: "",
spells: "",
inventory: [],
foundryActorId: actor?.id ?? null,
...over,
};
}
test("Dragonroll's background becomes the actor's background item, referenced by id", async () => {
const actor = makeStubActor("Thalia", {
system: { details: { background: "" } },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, { background: "Soldier" })],
}).start();
const background = actor.items.contents.find((item) => item.type === "background");
assert.ok(background, "the character's background stands in Foundry as an item");
assert.equal(background.name, "Soldier");
assert.equal(referenceId(actor, "background"), background.id, "its details reference points at the item");
assert.equal(actor.system.details.background, background.id);
assert.deepEqual(world.logs, [], "applying the character did not warn");
});
test("the background an earlier sync invented is taken back out", async () => {
// What the bug left behind: an item named after the id the details field held, next to
// the real background, and a reference the old sync overwrote with that id.
const actor = makeStubActor("Thalia", {
system: { details: { background: ID_GONE } },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [
{ _id: ID_SOLDIER, name: "Soldier", type: "background", flags: { [MODULE_ID]: { syncedItem: true } } },
{ _id: "item-bogus", name: ID_GONE, type: "background", flags: { [MODULE_ID]: { syncedItem: true } } },
],
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, { background: "Soldier" })],
}).start();
assert.deepEqual(world.itemNames(actor), [["background", "Soldier"]], "only the real background is left");
assert.equal(referenceId(actor, "background"), ID_SOLDIER, "and the reference resolves to it");
});
test("a background taken off in Dragonroll clears the reference", async () => {
const actor = makeStubActor("Thalia", {
system: { details: { background: ID_SOLDIER } },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [
{ _id: ID_SOLDIER, name: "Soldier", type: "background", flags: { [MODULE_ID]: { syncedItem: true } } },
],
});
const world = await makeWorld({ actors: [actor], remoteActors: [campaignCharacter(actor)] }).start();
assert.deepEqual(world.itemNames(actor), [], "the background item went with it");
assert.equal(referenceId(actor, "background"), "", "and no reference is left pointing at nothing");
});
test("a species never lands in the details reference as a name", async () => {
const actor = makeStubActor("Thalia", {
// A species picked in the sheet: dnd5e made the race item and referenced it by id.
system: { details: { race: ID_HUMAN } },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [{ _id: ID_HUMAN, name: "Human", type: "race", flags: { [MODULE_ID]: { syncedItem: true } } }],
});
await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, { species: "Human", background: "Soldier" })],
}).start();
assert.equal(referenceId(actor, "race"), ID_HUMAN, "the species reference still points at the race item");
assert.notEqual(actor.system.details.race, "Human", "a name in it would resolve to nothing");
});
test("a species the world keeps as plain text is left to the world", async () => {
// An actor migrated from an older system release: no race item, the name is what the
// field holds, and Dragonroll has nothing to reference.
const actor = makeStubActor("Thalia", {
system: { details: { race: "Human" } },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
});
await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, { species: "Human" })],
}).start();
assert.equal(actor.system.details.race, "Human", "the text the sheet reads is kept as it was");
});
test("a character made in Dragonroll references the background it is created with", async () => {
const world = await makeWorld({ actors: [], remoteActors: [campaignCharacter(null, { background: "Soldier" })] }).start();
const [actor] = world.game.actors.contents;
assert.ok(actor, "the campaign's character was made in this world");
const background = actor.items.contents.find((item) => item.type === "background");
assert.ok(background, "created together with its background item");
assert.equal(background.name, "Soldier");
assert.equal(referenceId(actor, "background"), background.id, "referenced by that item's id, never its name");
});

View File

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

View File

@@ -0,0 +1,87 @@
// 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

@@ -35,12 +35,15 @@ 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 = {
@@ -48,7 +51,7 @@ function makeStubWorld({
syncToken, syncToken,
linkCode, linkCode,
linkUrl, linkUrl,
dragonrollApiUrl: "http://backend.test:5000", dragonrollApiUrl: endpoint,
}; };
const sandbox = { const sandbox = {
@@ -56,6 +59,10 @@ 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]),
@@ -109,6 +116,7 @@ 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;
@@ -174,6 +182,17 @@ 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" } },
@@ -255,6 +274,43 @@ 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,11 +180,16 @@ 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("getActorDirectoryEntryContext", null, options); await world.fire("getActorContextOptions", application, options);
const entry = options.find((option) => option.name === "Dragonroll: Force Sync"); const entry = options.find((option) => option.label === "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");
await entry.callback(actorIds.map((actorId) => ({ dataset: { actorId } }))); assert.ok(!entry.visible || entry.visible(), "the entry is visible for a linked GM world");
await entry.onClick(null, entries[0] ?? null);
await world.runTimers(); await world.runTimers();
} }
@@ -207,6 +212,7 @@ test("autosync on: Foundry CRUD events keep syncing with Dragonroll", async () =
const pushes = world.syncRequests(); const pushes = world.syncRequests();
assert.equal(pushes.length, 1); assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.actors[0]._id, "actor-1"); assert.equal(pushes[0].body.actors[0]._id, "actor-1");
assert.equal(pushes[0].body.replace, false, "a live actor change never asks Dragonroll to replace the campaign's edits");
}); });
test("autosync off: CRUD requests stop syncing", async () => { test("autosync off: CRUD requests stop syncing", async () => {
@@ -260,6 +266,7 @@ test("force sync sends selected actors to Dragonroll even with autosync off", as
const pushes = world.syncRequests(); const pushes = world.syncRequests();
assert.equal(pushes.length, 1); assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.fullSync, false, "a forced actor never prunes the campaign"); assert.equal(pushes[0].body.fullSync, false, "a forced actor never prunes the campaign");
assert.equal(pushes[0].body.replace, true, "a forced sync replaces everything the campaign holds for those actors");
assert.deepEqual(pushes[0].body.actors.map((actor) => actor._id), ["actor-2"]); assert.deepEqual(pushes[0].body.actors.map((actor) => actor._id), ["actor-2"]);
assert.deepEqual(world.notifications.filter(([kind]) => kind !== "info"), []); assert.deepEqual(world.notifications.filter(([kind]) => kind !== "info"), []);
}); });
@@ -295,7 +302,7 @@ test("force sync refuses an actor Dragonroll does not import", async () => {
assert.ok(world.notifications.some(([kind, text]) => kind === "warn" && text.includes("Cart"))); assert.ok(world.notifications.some(([kind, text]) => kind === "warn" && text.includes("Cart")));
}); });
test("turning autosync back on reconciles both sides again", async () => { test("turning autosync back on sends the world's snapshot again", async () => {
const world = makeStubWorld({ autoSync: false }); const world = makeStubWorld({ autoSync: false });
await world.fire("init"); await world.fire("init");
await world.fire("ready"); await world.fire("ready");
@@ -307,6 +314,4 @@ test("turning autosync back on reconciles both sides again", async () => {
assert.ok(world.syncRequests().some((request) => request.body?.fullSync === true), assert.ok(world.syncRequests().some((request) => request.body?.fullSync === true),
"the world sends its full snapshot again"); "the world sends its full snapshot again");
assert.ok(world.requests.some((request) => request.href.includes("foundry/sync/characters")),
"Dragonroll documents are applied back into the world");
}); });

View File

@@ -132,6 +132,8 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
}; };
const requireStub = (id) => { const requireStub = (id) => {
@@ -142,6 +144,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) }; if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/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/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`);
}; };
@@ -416,28 +419,6 @@ test("a module that says nothing about colours leaves the campaign's colour alon
assert.equal(sync.models["../models/Folder"].rows[0].color, "#7f00ff"); assert.equal(sync.models["../models/Folder"].rows[0].color, "#7f00ff");
}); });
test("the folder list the world reads back carries the colours the campaign picked", async () => {
const sync = loadSyncRoute({
seed: {
folders: [
{ _id: "folder-1", target: "item", foundryFolderId: "folder-melee", name: "Melee Weapons", color: "#0080ff" },
{ _id: "folder-2", target: "item", name: "Homebrew" },
{ _id: "folder-3", name: "Chapter 1" },
],
items: [{ _id: "item-1", name: "Longsword", foundryItemId: "item-1", folder: "folder-1" }],
},
});
const response = await sync.call("GET /sync/items");
assert.equal(response.status, "ok");
assert.equal(response.items.length, 1);
const coloured = response.folders.find((folder) => folder._id === "folder-1");
assert.equal(coloured.foundryFolderId, "folder-melee", "the world's folder to write the colour back to");
assert.equal(coloured.color, "#0080ff");
assert.ok(!response.folders.some((folder) => folder._id === "folder-3"), "only the item list's folders travel back");
});
test("every folder listing says which campaign list it belongs to", () => { test("every folder listing says which campaign list it belongs to", () => {
// The sidebar's four lists share the Folder model, so a listing that names no target // The sidebar's four lists share the Folder model, so a listing that names no target
// would show folders of the other lists between its own rows. The note routes and // would show folders of the other lists between its own rows. The note routes and
@@ -472,9 +453,6 @@ function makeWorld() {
requests: [], requests: [],
timers: new Map(), timers: new Map(),
intervals: new Map(), intervals: new Map(),
// What Dragonroll answers a folder reconcile with: the campaign's folders and the
// colours its user gave them.
remoteFolders: [],
nextTimerId: 1, nextTimerId: 1,
}; };
@@ -575,9 +553,7 @@ function makeWorld() {
method: options.method, method: options.method,
body: options.body ? JSON.parse(options.body) : null, body: options.body ? JSON.parse(options.body) : null,
}); });
const payload = { status: "ok", actors: [], items: [] }; return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
if (href.includes("foundry/sync/items")) payload.folders = state.remoteFolders;
return { ok: true, status: 200, json: async () => payload };
}, },
Actor: { async create() { return null; } }, Actor: { async create() { return null; } },
Item: { async create() { return null; } }, Item: { async create() { return null; } },
@@ -628,12 +604,6 @@ function makeWorld() {
await drain(); await drain();
} }
}; };
// The reconciles `setInterval` registered: what runs every few seconds on a world
// that is linked, and so what carries Dragonroll's folder colours back into the world.
state.runIntervals = async () => {
for (const interval of [...state.intervals.values()]) await interval.fn();
await drain();
};
state.linkedSetup = async () => { state.linkedSetup = async () => {
await state.fire("init"); await state.fire("init");
await state.fire("ready"); await state.fire("ready");
@@ -736,43 +706,6 @@ test("autosync off: folder changes stop syncing", async () => {
assert.deepEqual(world.syncRequests(), []); assert.deepEqual(world.syncRequests(), []);
}); });
// --- The colours the campaign gives those folders travel back to the world ---------
test("a folder coloured in the Dragonroll campaign is coloured in the world", async () => {
const world = await makeWorld().linkedSetup();
world.remoteFolders = [
{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: "#0080ff" },
// A folder the campaign made for its own items: there is no world document to colour.
{ _id: "db-homebrew", name: "Homebrew", color: "#00ff00" },
];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, "#0080ff");
assert.equal(world.folder("folder-ranged").color, null, "a folder the campaign says nothing about keeps what the world shows");
assert.deepEqual(world.requests.filter((request) => request.method === "POST"), [],
"Dragonroll's own write is not pushed back to the campaign as a world change");
});
test("a colour taken off in the campaign comes off the world's folder", async () => {
const world = await makeWorld().linkedSetup();
world.remoteFolders = [{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: null }];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, null, "uncoloured in the campaign is uncoloured in the world");
});
test("autosync off: the campaign's folder colours are not written into the world", async () => {
const world = await makeWorld().linkedSetup();
await world.game.settings.set("dragonroll-foundry", "autoSync", false);
world.remoteFolders = [{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: "#0080ff" }];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, "#8b0000", "the world keeps what it shows while autosync is off");
});
// --- The sidebar groups its items under those folders ---------------------------- // --- The sidebar groups its items under those folders ----------------------------
// `vm.compileFunction` is synchronous, so the service is ready right away. Loading it with // `vm.compileFunction` is synchronous, so the service is ready right away. Loading it with

View File

@@ -92,9 +92,6 @@ test("the item window shows the info and offers both icon sources", () => {
test("the Foundry module sends item icons as URLs Dragonroll can load", () => { test("the Foundry module sends item icons as URLs Dragonroll can load", () => {
// actor-embedded items go through the same serializer as world items // actor-embedded items go through the same serializer as world items
assert.match(moduleSource, /items:\s*\(actor\.items\?\.contents\?\.map\(serializeFoundryItem\)/); assert.match(moduleSource, /items:\s*\(actor\.items\?\.contents\?\.map\(serializeFoundryItem\)/);
// the icon chosen in Dragonroll travels back into the linked world
assert.match(moduleSource, /const image = getDragonrollImageUrl\(entry\.image\);\s*if \(image\) updates\.img = image;/);
assert.match(moduleSource, /img: getDragonrollImageUrl\(entry\.image\) \|\| undefined,\s*system:/);
}); });
test("every locale names the item window and its icon controls", () => { test("every locale names the item window and its icon controls", () => {

View File

@@ -0,0 +1,162 @@
// 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("an uploaded file is offered like any other entry, under its name", () => {
const suggestions = autocomplete.BuildLinkSuggestions({
media: [{ _id: "f1", name: "harbour.png" }, { _id: "f2", file: "no-name.png" }],
});
assert.deepEqual(suggestions, [{ id: "f1", label: "harbour.png", type: "media" }]);
});
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 lists", () => {
for (const path of ["/note/all", "/actor/list", "/item/list", "/map/list", "/media/list"]) {
assert.ok(targets.includes(path), `the link entries do not read ${path}`);
}
assert.match(targets, /CACHE_TTL/, "the 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", "media"]) {
const key = type === "media" ? "media" : `${type}s`;
assert.ok(sections[key], `${locale} has no label for the ${type} section`);
}
}
});
}
wiringTests();

View File

@@ -184,6 +184,8 @@ function loadNoteRoutes({ ownsCampaign = true, notes = [], folders = [], deleted
findById: (id) => mongooseQuery(notes.find((note) => note._id === id) ?? null), findById: (id) => mongooseQuery(notes.find((note) => note._id === id) ?? null),
deleteOne: () => mongooseQuery({ deletedCount }), deleteOne: () => mongooseQuery({ deletedCount }),
}, },
// The note lists also carry the media files standing beside the notes.
"../models/Media": { find: () => mongooseQuery([]) },
"../models/Folder": { "../models/Folder": {
find: () => mongooseQuery(folders), find: () => mongooseQuery(folders),
// models/Folder.js: the note tree is every folder that is not one of the other // models/Folder.js: the note tree is every folder that is not one of the other

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

@@ -0,0 +1,196 @@
// Tests for the walls of a map: straight segments drawn with the wall tool, stored with the map in
// image pixels, in three kinds (normal, terrain, invisible).
//
// Same set-up as tests/map-tokens.test.js, which the repository root runs without installing
// anything: the express router is loaded into `node:vm` with its models stubbed, and the last checks
// read the viewer template, where the drawing wiring itself is what has to stay right.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and lets `select()`
// and `sort()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Loads an express router file with every module it requires stubbed out.
function loadRouter(relativeParts, stubs) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../services/storage") return { single: () => (req, res, next) => next() };
if (!(id in stubs)) throw new Error(`require("${id}") is not stubbed`);
return stubs[id];
};
const moduleStub = { exports: {} };
vm.compileFunction(readRepoFile(...relativeParts), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, { body = {}, query = {}, params = {}, user = { id: "user-1" } } = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; } };
await handlers[handlers.length - 1]({ body, query, params, user }, res);
return res.payload;
}
return { routes, call };
}
function makeMap(walls = []) {
return { _id: "map-1", campaign: "campaign-1", walls, save: async () => {} };
}
function loadMapRoutes({ ownsCampaign = true, maps = [] } = {}) {
return loadRouter(["backend", "src", "routes", "map.js"], {
"../models/Campaign": { findOne: () => mongooseQuery(ownsCampaign ? { _id: "campaign-1" } : null) },
"../models/Map": { findById: (id) => mongooseQuery(maps.find((map) => map._id === id) ?? null) },
"../models/Note": { findOne: () => mongooseQuery(null) },
"../models/Actor": { findOne: () => mongooseQuery(null) },
"../models/Folder": { find: () => mongooseQuery([]), belongsToSection: async () => true },
});
}
function wallRouteTests() {
test("a wall is saved with its type and both of its spots in image pixels", async () => {
const map = makeMap();
const api = loadMapRoutes({ maps: [map] });
const response = await api.call("POST /wall", {
body: { id: "map-1", type: "terrain", x1: "10.4", y1: "-3", x2: "70.6", y2: "40" },
});
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [{ type: "terrain", x1: 10, y1: 0, x2: 71, y2: 40 }]);
});
test("a wall without a known type is a normal wall", async () => {
const map = makeMap();
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /wall", { body: { id: "map-1", x1: 0, y1: 0, x2: 50, y2: 0 } });
await api.call("POST /wall", { body: { id: "map-1", type: "door", x1: 0, y1: 50, x2: 50, y2: 50 } });
assert.deepEqual(map.walls.map((wall) => wall.type), ["normal", "normal"]);
});
test("the three kinds of wall are kept apart", async () => {
const map = makeMap();
const api = loadMapRoutes({ maps: [map] });
for (const type of ["normal", "terrain", "invisible"]) {
await api.call("POST /wall", { body: { id: "map-1", type, x1: 0, y1: 0, x2: 10, y2: 10 } });
}
assert.deepEqual(map.walls.map((wall) => wall.type), ["normal", "terrain", "invisible"]);
});
test("a wall needs its map and both of its ends", async () => {
const map = makeMap();
const api = loadMapRoutes({ maps: [map] });
assert.equal((await api.call("POST /wall", { body: { x1: 0, y1: 0, x2: 10, y2: 10 } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /wall", { body: { id: "map-1", x1: 0, y1: 0, y2: 10 } })).msg, "errors.missing-data");
assert.deepEqual(map.walls, []);
});
test("a map of somebody else's campaign takes no wall", async () => {
const map = makeMap();
const api = loadMapRoutes({ ownsCampaign: false, maps: [map] });
const response = await api.call("POST /wall", { body: { id: "map-1", type: "terrain", x1: 0, y1: 0, x2: 10, y2: 10 } });
assert.equal(response.msg, "unauthorized");
assert.deepEqual(map.walls, []);
});
test("removing a wall takes the one it is given and keeps the others", async () => {
const map = makeMap([
{ _id: "wall-1", type: "normal", x1: 0, y1: 0, x2: 50, y2: 0 },
{ _id: "wall-2", type: "invisible", x1: 50, y1: 0, x2: 50, y2: 50 },
]);
const api = loadMapRoutes({ maps: [map] });
const response = await api.call("POST /unwall", { body: { id: "map-1", wall: "wall-1" } });
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [{ _id: "wall-2", type: "invisible", x1: 50, y1: 0, x2: 50, y2: 50 }]);
});
test("removing a wall of a map of somebody else keeps it", async () => {
const map = makeMap([{ _id: "wall-1", type: "normal", x1: 0, y1: 0, x2: 50, y2: 0 }]);
const api = loadMapRoutes({ ownsCampaign: false, maps: [map] });
const response = await api.call("POST /unwall", { body: { id: "map-1", wall: "wall-1" } });
assert.equal(response.msg, "unauthorized");
assert.equal(map.walls.length, 1);
});
test("the map schema stores walls of the three kinds", () => {
const model = readRepoFile("backend", "src", "models", "Map.js");
assert.match(model, /walls:\s*\[/);
for (const type of ["normal", "terrain", "invisible"]) {
assert.match(model, new RegExp(`['"]${type}['"]`), `the ${type} wall is missing from the schema`);
}
});
}
function mapViewerWallWiringTests() {
const pane = readRepoFile("frontend", "app", "components", "viewer", "map", "MapViewerPane.vue");
test("the wall tool is a toggle of the map toolbar", () => {
assert.match(pane, /:class="\{ selected: wallMode \}"/);
assert.match(pane, /@click="toggleWalls"/);
assert.match(pane, /const WALL_TYPES = \['normal', 'terrain', 'invisible'\]/);
assert.match(pane, /v-for="type in WALL_TYPES"/);
});
test("a drag with the wall tool on draws a wall instead of panning the map", () => {
assert.match(pane, /if \(wallMode\.value\) \{[^}]*imagePointOf\(event\)/);
assert.match(pane, /drawingWall\.value = \{ x1: spot\.x, y1: spot\.y, x2: spot\.x, y2: spot\.y \}/);
assert.match(pane, /['"]\/map\/wall['"]/);
assert.match(pane, /['"]\/map\/unwall['"]/);
});
test("a click that did not drag leaves no wall behind", () => {
assert.match(pane, /Math\.hypot\(wall\.x2 - wall\.x1, wall\.y2 - wall\.y1\) >= 2\) await saveWall\(wall\)/);
});
test("walls are drawn over the image and only catch the mouse with the tool on", () => {
assert.match(pane, /class="map-walls"/);
assert.match(pane, /\.map-walls\s*\{[^}]*pointer-events:\s*none/);
assert.match(pane, /\.map-walls\.editing \.map-wall-hit\s*\{[^}]*pointer-events:\s*stroke/);
assert.match(pane, /@contextmenu\.stop\.prevent="onWallContextMenu\(wall\)"/);
});
test("invisible walls are hidden until the wall tool is on", () => {
assert.match(pane, /function wallVisible\(wall\) \{\s*return wall\.type !== 'invisible' \|\| wallMode\.value;/);
});
}
wallRouteTests();
mapViewerWallWiringTests();

157
tests/note-links.test.js Normal file
View File

@@ -0,0 +1,157 @@
// 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}`);
}
}
});

230
tests/note-media.test.js Normal file
View File

@@ -0,0 +1,230 @@
// Tests for the media files that stand in the note tree beside the notes (the sidebar lists
// images, sounds, videos and documents with an icon of their type, the way a file explorer does).
//
// The repository root installs no dependencies, so the media routes run against a stubbed
// `require`, the note lists are read out of the real route file the same way, and the sidebar and
// nested list are read as text like tests/sidebar-entity-entry.test.js reads them.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
function loadRoutes(file, models) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "path") return path;
// The upload folder and the file it drops are not what these checks are about.
if (id === "fs") return { unlink: (file, done) => done() };
if (id === "../services/storage") return { single: () => (req, res, next) => next() };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", file), ["require", "module", "exports", "__dirname"])(
requireStub, moduleStub, moduleStub.exports, path.join(__dirname, "..", "backend", "src", "routes")
);
return async function call(route, { body = {}, query = {}, file = null } = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; } };
await handlers[handlers.length - 1]({ body, query, file, user: { id: "user-1" } }, res);
return res.payload;
};
}
function loadMediaRoutes({ ownsCampaign = true, media = null, folderOk = true, list = [] } = {}) {
const deleted = [];
const api = loadRoutes("media.js", {
"../models/Campaign": { findOne: () => ({ lean: async () => (ownsCampaign ? { _id: "campaign-1" } : null) }) },
"../models/Folder": { belongsToSection: async () => folderOk },
"../models/Media": Object.assign(
function Media(data) { Object.assign(this, { _id: "media-new", save: async () => {} }, data); },
{
findById: async () => media,
find: (filter) => ({
select() { return this; },
sort() { return this; },
lean: async () => (filter.campaign === "campaign-1" ? list : []),
}),
deleteOne: async (filter) => { deleted.push(filter); return { deletedCount: 1 }; },
}
),
});
return { api, deleted };
}
function seededMedia() {
return {
_id: "media-1", campaign: "campaign-1", file: "file-1.png", mimeType: "image/png",
save: async () => {},
};
}
// --- Routes ---------------------------------------------------------------------
test("an uploaded file becomes a media row of the campaign", async () => {
const { api } = loadMediaRoutes();
const response = await api("POST /upload", {
body: { campaign: "campaign-1" },
file: { filename: "file-1.png", mimetype: "image/png", originalname: "harbour.png" },
});
assert.equal(response.status, "ok");
assert.equal(response.media.name, "harbour.png");
assert.equal(response.media.file, "file-1.png");
assert.equal(response.media.mimeType, "image/png");
assert.equal(response.media.folder, null);
});
test("an upload into another campaign is refused", async () => {
const { api } = loadMediaRoutes({ ownsCampaign: false });
const response = await api("POST /upload", {
body: { campaign: "campaign-1" },
file: { filename: "file-1.png", mimetype: "image/png", originalname: "harbour.png" },
});
assert.equal(response.msg, "unauthorized");
});
test("a campaign's media can be listed so a note can link to it", async () => {
const list = [{ _id: "media-1", name: "harbour.png", file: "file-1.png", mimeType: "image/png" }];
const { api } = loadMediaRoutes({ list });
const response = await api("GET /list", { query: { campaign: "campaign-1" } });
assert.equal(response.status, "ok");
assert.deepEqual(response.media, list);
});
test("the media list of another campaign is refused", async () => {
const { api } = loadMediaRoutes({ ownsCampaign: false });
const response = await api("GET /list", { query: { campaign: "campaign-1" } });
assert.equal(response.msg, "unauthorized");
});
test("a media file only stands in a note folder", async () => {
const { api } = loadMediaRoutes({ folderOk: false });
const response = await api("POST /upload", {
body: { campaign: "campaign-1", folder: "actor-folder-1" },
file: { filename: "file-1.png", mimetype: "image/png", originalname: "harbour.png" },
});
assert.equal(response.msg, "errors.notfound");
});
test("a media row moves into a folder and back to the root", async () => {
const media = seededMedia();
const { api } = loadMediaRoutes({ media });
const moved = await api("POST /update", { body: { id: "media-1", folder: "folder-1" } });
assert.equal(moved.status, "ok");
assert.equal(media.folder, "folder-1");
await api("POST /update", { body: { id: "media-1", folder: null } });
assert.equal(media.folder, null);
});
test("deleting a media file of somebody else's campaign leaves it where it is", async () => {
const { api, deleted } = loadMediaRoutes({ media: seededMedia(), ownsCampaign: false });
const response = await api("POST /delete", { body: { id: "media-1" } });
assert.equal(response.msg, "unauthorized");
assert.equal(deleted.length, 0, "the row must not be dropped");
});
test("deleting a media file drops its row", async () => {
const { api, deleted } = loadMediaRoutes({ media: seededMedia() });
const response = await api("POST /delete", { body: { id: "media-1" } });
assert.equal(response.status, "ok");
assert.equal(deleted.length, 1);
});
test("a deleted note folder takes its media rows to the root with it", () => {
const folderRoute = read("backend", "src", "routes", "folder.js");
assert.match(folderRoute, /Media\.updateMany\(\s*\{ folder: folderId \}/);
});
// --- Both note lists carry the media standing at their level ---------------------
test("the note tree's root list carries the media at the root", () => {
const noteRoute = read("backend", "src", "routes", "note.js");
assert.match(noteRoute, /Media\.find\(\{ campaign, folder: null \}\)/);
const list = /router\.get\('\/list'[\s\S]*?res\.json\(\{ status: 'ok', folders, notes: rootNotes, media \}\)/.exec(noteRoute);
assert.ok(list, "expected /note/list to answer with media");
});
test("a folder's list carries the media standing in that folder", () => {
const noteRoute = read("backend", "src", "routes", "note.js");
assert.match(noteRoute, /Media\.find\(\{ campaign, folder \}\)/);
assert.match(noteRoute, /res\.json\(\{ status: 'ok', subfolders, notes, media \}\)/);
});
// --- The sidebar -----------------------------------------------------------------
test("the notes section offers a media upload", () => {
const sidebar = read("frontend", "app", "components", "partials", "ContentSidebar.vue");
assert.match(sidebar, /chooseMedia/);
assert.match(sidebar, /type="file" multiple @change="uploadMedia"/);
assert.match(sidebar, /Server\(\)\.post\('\/media\/upload'/);
});
test("the note tree passes each level's media down to its rows", () => {
const sidebar = read("frontend", "app", "components", "partials", "ContentSidebar.vue");
assert.match(sidebar, /:media="media"/);
const nested = read("frontend", "app", "components", "partials", "NestedNoteList.vue");
assert.match(nested, /:media="getFolderMedia\(folder\._id\)"/);
assert.match(nested, /v-for="item in media"/);
});
test("every media row leads with the icon of its type", () => {
const nested = read("frontend", "app", "components", "partials", "NestedNoteList.vue");
assert.match(nested, /type\.startsWith\('image\/'\)[\s\S]*media-image\.svg/);
assert.match(nested, /type\.startsWith\('audio\/'\)[\s\S]*music-note\.svg/);
assert.match(nested, /type\.startsWith\('video\/'\)[\s\S]*media-video\.svg/);
assert.match(nested, /application\/pdf[\s\S]*page\.svg/);
});
test("a media window is registered and reads the file from /api/public", () => {
const definitions = read("frontend", "app", "services", "WindowDefinitions.js");
assert.match(definitions, /media_viewer: \{[\s\S]*MediaViewerWindow\.vue/);
const viewer = read("frontend", "app", "components", "windows", "MediaViewerWindow.vue");
assert.match(viewer, /getBaseUrl\(\)\}\/public\/\$\{media\.file\}/);
});
test("an embedded image from the media list is drawn in the note", () => {
const embed = read("frontend", "app", "components", "viewer", "content", "EmbeddedEntry.vue");
assert.match(embed, /target\.value\?\.type === 'media'/, "media becomes an embed target");
assert.match(embed, /startsWith\('image\/'\)/, "only an image is drawn as a picture");
assert.match(embed, /getBaseUrl\(\)\}\/public\/\$\{entry\.value\.file\}/, "the upload is served from /api/public");
assert.match(embed, /class="embed-image"/);
const note = read("frontend", "app", "components", "viewer", "content", "Note.vue");
assert.match(note, /CreateWindow\('media_viewer'/, "a plain link to a media file opens its window");
});
test("every locale names the upload and the media window", () => {
for (const locale of ["en", "es", "ca"]) {
const campaigns = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"));
const windows = JSON.parse(read("frontend", "i18n", "locales", locale, "windows.json"));
assert.ok(campaigns.media?.upload, `${locale} must name the media upload`);
assert.ok(campaigns.media?.["upload-error"], `${locale} must say an upload failed`);
assert.ok(windows["media-viewer"], `${locale} must name the media window`);
}
});

View File

@@ -0,0 +1,198 @@
// Tests for the Obsidian plugin's automatic sync: vault events push edits, create notes for files
// added to the campaign folder, and delete the note of a deleted file. The plugin is loaded from
// source with a stubbed `obsidian` module so the real class runs under node:test.
//
// 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 SOURCE = fs.readFileSync(
path.join(__dirname, "..", "obsidian-plugin", "obsidian-dragonroll", "main.js"),
"utf8",
);
function loadPluginClass() {
const module = { exports: {} };
const requireStub = (name) => {
if (name !== "obsidian") throw new Error(`unexpected require: ${name}`);
return {
Notice: class { constructor(message) { this.message = message; } },
Plugin: class {},
PluginSettingTab: class {},
Setting: class {},
normalizePath: (value) => value,
requestUrl: async () => { throw new Error("network is not stubbed"); },
};
};
new Function("module", "exports", "require", SOURCE)(module, module.exports, requireStub);
return module.exports;
}
const DragonrollPlugin = loadPluginClass();
const FILE = {
path: "Dragonroll/Campaign/Session 1.md",
basename: "Session 1",
extension: "md",
};
const BUFFER = [
"---",
"dragonrollId: n1",
"dragonrollCampaign: c1",
"tags: [session]",
"---",
"# Hello",
"",
].join("\n");
function makePlugin({ file = FILE, frontmatter = {}, settings = {}, buffer = BUFFER } = {}) {
const plugin = new DragonrollPlugin();
plugin.settings = { token: "t", campaignId: "c1", autoSync: true, snapshots: {}, ...settings };
plugin.status = { setText() {} };
plugin.suspended = false;
plugin.internalWrites = new Set();
plugin.linkedNotes = new Map();
plugin.syncChain = Promise.resolve();
plugin.saveSettings = async () => {};
plugin.requests = [];
plugin.request = async (url, options = {}) => {
plugin.requests.push({ url, options });
if (url === "/campaign/list") return { status: "ok", campaigns: [{ _id: "c1", name: "Campaign" }] };
if (url === "/note/create") return { status: "ok", note: { _id: "n2" } };
if (url === "/note/update") return { status: "ok", note: { _id: "n1" } };
return { status: "ok" };
};
plugin.app = {
vault: {
getAbstractFileByPath: () => file,
read: async () => buffer,
getMarkdownFiles: () => [file],
},
metadataCache: {
getFileCache: () => ({ frontmatter: { dragonrollId: "n1", dragonrollCampaign: "c1", ...frontmatter } }),
},
fileManager: {
processFrontMatter: async (target, apply) => {
const written = {};
apply(written);
plugin.writtenFrontmatter = written;
},
},
};
return plugin;
}
async function settle(plugin) {
await plugin.syncChain;
}
test("vault events are ignored when auto-sync is off, the file is not markdown, or the plugin wrote it", async () => {
const off = makePlugin({ settings: { autoSync: false } });
off.onVaultChange(FILE);
await settle(off);
assert.equal(off.requests.length, 0);
const notMarkdown = makePlugin();
notMarkdown.onVaultChange({ ...FILE, extension: "pdf" });
await settle(notMarkdown);
assert.equal(notMarkdown.requests.length, 0);
const importing = makePlugin();
importing.suspended = true;
importing.onVaultChange(FILE);
await settle(importing);
assert.equal(importing.requests.length, 0);
const ownWrite = makePlugin();
ownWrite.internalWrites.add(FILE.path);
ownWrite.onVaultChange(FILE);
await settle(ownWrite);
assert.equal(ownWrite.requests.length, 0);
});
test("saving a linked note updates it with the file content, frontmatter stripped", async () => {
const plugin = makePlugin();
plugin.onVaultChange(FILE);
await settle(plugin);
assert.equal(plugin.requests.length, 1);
const [request] = plugin.requests;
assert.equal(request.url, "/note/update");
assert.deepEqual(request.options.body, {
id: "n1",
title: "Session 1",
content: "---\ntags: [session]\n---\n# Hello\n",
});
assert.ok(plugin.settings.snapshots.n1, "the pushed version becomes the import baseline");
plugin.onVaultChange(FILE);
await settle(plugin);
assert.equal(plugin.requests.length, 1, "an unchanged save is not pushed again");
});
test("a new note inside the campaign folder becomes a campaign note", async () => {
const plugin = makePlugin({
file: { path: "Dragonroll/Campaign/New Note.md", basename: "New Note", extension: "md" },
frontmatter: { dragonrollId: undefined },
buffer: "Body",
});
plugin.onVaultChange(plugin.app.vault.getMarkdownFiles()[0]);
await settle(plugin);
const create = plugin.requests.find((request) => request.url === "/note/create");
assert.ok(create, "the new file was not created in the campaign");
assert.deepEqual(create.options.body, { title: "New Note", content: "Body", campaign: "c1" });
assert.deepEqual(plugin.writtenFrontmatter, {
dragonrollId: "n2",
dragonrollCampaign: "c1",
dragonrollTitle: "New Note",
});
assert.deepEqual(plugin.linkedNotes.get("Dragonroll/Campaign/New Note.md"), { noteId: "n2", campaignId: "c1" });
});
test("a new note outside the campaign folder stays local", async () => {
const plugin = makePlugin({
file: { path: "Notes/Idea.md", basename: "Idea", extension: "md" },
frontmatter: { dragonrollId: undefined },
buffer: "Body",
});
plugin.onVaultChange(plugin.app.vault.getMarkdownFiles()[0]);
await settle(plugin);
assert.equal(plugin.requests.length, 0);
});
test("deleting a linked file, or a folder holding linked files, deletes the campaign notes", async () => {
const plugin = makePlugin();
plugin.settings.snapshots.n1 = "sig";
plugin.linkedNotes.set(FILE.path, { noteId: "n1", campaignId: "c1" });
plugin.linkedNotes.set("Dragonroll/Campaign/Other.md", { noteId: "n3", campaignId: "c1" });
plugin.onVaultDelete(FILE);
await settle(plugin);
assert.deepEqual(plugin.requests.map((request) => request.url), ["/note/delete"]);
assert.deepEqual(plugin.requests[0].options.body, { id: "n1" });
assert.equal(plugin.settings.snapshots.n1, undefined);
plugin.onVaultDelete({ path: "Dragonroll/Campaign" });
await settle(plugin);
assert.deepEqual(plugin.requests[1].options.body, { id: "n3" });
assert.equal(plugin.linkedNotes.size, 0);
});
test("deleting a file linked to another campaign leaves that campaign alone", async () => {
const plugin = makePlugin();
plugin.linkedNotes.set(FILE.path, { noteId: "n9", campaignId: "c2" });
plugin.onVaultDelete(FILE);
await settle(plugin);
assert.equal(plugin.requests.length, 0);
});

View File

@@ -0,0 +1,82 @@
// 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

@@ -16,6 +16,10 @@ const source = fs.readFileSync(
path.join(__dirname, "..", "frontend", "app", "components", "partials", "ContentSidebar.vue"), path.join(__dirname, "..", "frontend", "app", "components", "partials", "ContentSidebar.vue"),
"utf8" "utf8"
); );
const noteListSource = fs.readFileSync(
path.join(__dirname, "..", "frontend", "app", "components", "partials", "NestedNoteList.vue"),
"utf8"
);
// `selector` is inserted verbatim, so escape the `.` of a class combination (`entity-entry\\.anchored`). // `selector` is inserted verbatim, so escape the `.` of a class combination (`entity-entry\\.anchored`).
// A trailing `\.entity-entry\s*\{` cannot match `.entity-entry:hover` or `.entity-entry-name`, so the // A trailing `\.entity-entry\s*\{` cannot match `.entity-entry:hover` or `.entity-entry-name`, so the
@@ -86,3 +90,22 @@ test("a long entry name wraps instead of pushing the entry out of the sidebar",
assert.ok(name, "expected a .entity-entry-name style rule"); assert.ok(name, "expected a .entity-entry-name style rule");
assert.match(name, /(word-break|overflow-wrap):/, "an unbreakable name has to wrap inside the entry"); assert.match(name, /(word-break|overflow-wrap):/, "an unbreakable name has to wrap inside the entry");
}); });
test("every entity entry leads with the icon of what it is", () => {
for (const icon of ["user.svg", "box.svg", "map.svg"]) {
assert.match(source, new RegExp(`class="entity-entry-icon"[^>]*${icon.replace('.', '\\.')}`),
`expected the ${icon} icon on an entry row`);
}
// An item that brings its own picture still has the type icon when it carries none.
assert.match(source, /v-else class="entity-entry-icon"[^>]*box\.svg/);
const icon = ruleFor("entity-entry-icon");
assert.ok(icon, "expected a .entity-entry-icon style rule");
assert.match(declaration(icon, "width"), /^\d+px$/);
});
test("note rows lead with the page icon and media rows with the icon of their type", () => {
assert.match(noteListSource, /class="note-link-icon"[^>]*journal-page\.svg/);
assert.match(noteListSource, /v-for="item in media"[\s\S]*media-link-icon/);
});

View File

@@ -0,0 +1,148 @@
// 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();