35 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
dcc6d7a14b kdsklkdsl
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m3s
2026-10-16 00:02:51 +02:00
227fff1351 Merge pull request 'Fix #90: Add a docs button' (#93) from ai/issue-90 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #93
2026-10-15 22:02:07 +00:00
a64fe499e9 Merge branch 'master' into ai/issue-90
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:02:01 +00:00
b75ee05276 Merge pull request 'Fix #91: Make character column always visible' (#94) from ai/issue-91 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #94
2026-10-15 22:01:54 +00:00
bc7231a1da Merge branch 'master' into ai/issue-91
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:01:49 +00:00
252ae2d6b2 Merge pull request 'Fix #89: Traits and items are mixed up' (#92) from ai/issue-89 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #92
2026-10-15 22:01:34 +00:00
Gitea OpenCode Agent
30e23b643c Fix issue #91: Make character column always visible
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:56:49 +00:00
Gitea OpenCode Agent
8376acfc6b Fix issue #90: Add a docs button
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:42:03 +00:00
Gitea OpenCode Agent
f8dae95563 Fix issue #89: Traits and items are mixed up
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:36:44 +00:00
98aa3be078 Merge pull request 'Fix #85: Style corrections on /docs' (#88) from ai/issue-85 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m5s
Reviewed-on: #88
2026-10-15 20:56:27 +00:00
80c6b1b62f Merge branch 'master' into ai/issue-85
All checks were successful
Test / test (push) Successful in 1s
2026-10-15 20:56:19 +00:00
2cce19e032 Merge pull request 'Fix #84: Double click token' (#87) from ai/issue-84 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #87
2026-10-15 20:56:13 +00:00
abacfeca40 Merge branch 'master' into ai/issue-84
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:56:08 +00:00
f925881a54 Merge pull request 'Fix #83: Add more things to the character sheet' (#86) from ai/issue-83 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #86
2026-10-15 20:55:58 +00:00
Gitea OpenCode Agent
9aad484fe9 Fix issue #85: Style corrections on /docs
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:55:08 +00:00
Gitea OpenCode Agent
5ee7353123 Fix issue #84: Double click token
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:44:53 +00:00
Gitea OpenCode Agent
f0ffa2f72b Fix issue #83: Add more things to the character sheet
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:40:05 +00:00
90 changed files with 7070 additions and 1309 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

@@ -34,10 +34,65 @@ const ActorSchema = new Schema({
max: { type: Number, min: 0, default: 1 } max: { type: Number, min: 0, default: 1 }
}, },
proficiencies: { type: String, default: '' }, proficiencies: { type: String, default: '' },
// The skills the character is proficient with (Syndria98/dragonroll#83). Dragonroll holds
// whole names; services/actor-foundry.js translates the short keys a Foundry world uses.
skills: {
acrobatics: { type: Boolean, default: false },
animalHandling: { type: Boolean, default: false },
arcana: { type: Boolean, default: false },
athletics: { type: Boolean, default: false },
deception: { type: Boolean, default: false },
history: { type: Boolean, default: false },
insight: { type: Boolean, default: false },
intimidation: { type: Boolean, default: false },
investigation: { type: Boolean, default: false },
medicine: { type: Boolean, default: false },
nature: { type: Boolean, default: false },
perception: { type: Boolean, default: false },
performance: { type: Boolean, default: false },
persuasion: { type: Boolean, default: false },
religion: { type: Boolean, default: false },
sleightOfHand: { type: Boolean, default: false },
stealth: { type: Boolean, default: false },
survival: { type: Boolean, default: false }
},
// Which of the six saving throws the character adds its proficiency bonus to.
savingThrows: {
str: { type: Boolean, default: false },
dex: { type: Boolean, default: false },
con: { type: Boolean, default: false },
int: { type: Boolean, default: false },
wis: { type: Boolean, default: false },
cha: { type: Boolean, default: false }
},
// Tool and language proficiencies: plain names, one per entry. The free-form
// `proficiencies` text keeps whatever else the character is proficient with
// (armour and weapons, say), which has no list of its own.
tools: [{ type: String, trim: true }],
languages: [{ type: String, trim: true }],
// The coins the character holds, in the five D&D denominations.
currency: {
pp: { type: Number, min: 0, default: 0 },
gp: { type: Number, min: 0, default: 0 },
ep: { type: Number, min: 0, default: 0 },
sp: { type: Number, min: 0, default: 0 },
cp: { type: Number, min: 0, default: 0 }
},
inventory: [{ inventory: [{
name: { type: String, trim: true, default: '' }, name: { type: String, trim: true, default: '' },
quantity: { type: Number, min: 1, default: 1 }, quantity: { type: Number, min: 1, default: 1 },
weight: { type: Number, min: 0, default: 0 } weight: { type: Number, min: 0, default: 0 },
// The gear's own picture: what a Foundry world sends with the item it stands
// for, shown on the left of the inventory row.
icon: { type: String, default: '' }
}],
// The character's features as the world writes them (Syndria98/dragonroll#89): one row
// per Foundry `feat` item, with the item's own picture and text. The free-form `traits`
// above keeps the details a world has no item for.
features: [{
name: { type: String, trim: true, default: '' },
description: { type: String, default: '' },
icon: { type: String, default: '' }
}], }],
traits: { type: String, default: '' }, traits: { type: String, default: '' },
spells: { type: String, default: '' }, spells: { type: String, default: '' },

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

@@ -22,6 +22,13 @@ function barPool(existing, value) {
return { current, max }; return { current, max };
} }
// The tool and language lists (Syndria98/dragonroll#83): plain names, blank ones and
// repeats dropped.
function textList(value) {
if (!Array.isArray(value)) return [];
return [...new Set(value.map((name) => String(name).trim()).filter(Boolean))];
}
// Folders the campaign's actors are grouped into, in the shape the sidebar groups by // Folders the campaign's actors are grouped into, in the shape the sidebar groups by
// (the notes, items and maps each keep a tree of their own, see models/Folder.js). // (the notes, items and maps each keep a tree of their own, see models/Folder.js).
async function actorFolders(campaignId) { async function actorFolders(campaignId) {
@@ -65,7 +72,10 @@ router.post('/create', async (req, res) => {
router.post('/update', async (req, res) => { router.post('/update', async (req, res) => {
try { try {
const { id, name, species, className, subclass, level, abilityScores, armorClass, speed, hitPoints, hitDice, proficiencies, inventory, traits, spells, image, folder } = req.body; const {
id, name, species, className, subclass, level, abilityScores, armorClass, speed, hitPoints, hitDice,
proficiencies, skills, savingThrows, tools, languages, currency, inventory, features, traits, spells, image, folder
} = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' }); if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const actor = await Actor.findById(id); const actor = await Actor.findById(id);
@@ -92,7 +102,16 @@ router.post('/update', async (req, res) => {
if (hitPoints !== undefined) actor.hitPoints = barPool(actor.hitPoints, hitPoints); if (hitPoints !== undefined) actor.hitPoints = barPool(actor.hitPoints, hitPoints);
if (hitDice !== undefined) actor.hitDice = barPool(actor.hitDice, hitDice); if (hitDice !== undefined) actor.hitDice = barPool(actor.hitDice, hitDice);
if (proficiencies !== undefined) actor.proficiencies = proficiencies; if (proficiencies !== undefined) actor.proficiencies = proficiencies;
// The lists the sheet toggles and fills in (Syndria98/dragonroll#83): which skills
// and saving throws the character is proficient with, its tools, its languages and
// the coins it carries.
if (skills !== undefined) actor.skills = skills;
if (savingThrows !== undefined) actor.savingThrows = savingThrows;
if (tools !== undefined) actor.tools = textList(tools);
if (languages !== undefined) actor.languages = textList(languages);
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

@@ -9,6 +9,8 @@ const Item = require('../models/Item');
const Folder = require('../models/Folder'); 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 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;
@@ -41,10 +43,36 @@ function requestMatchesWorld(campaign, worldId) {
return typeof worldId === 'string' && worldId === campaign.foundryWorldId; return typeof worldId === 'string' && worldId === campaign.foundryWorldId;
} }
async function saveFoundryActor(campaign, source, fullSync = false) { // Foundry serves its data directory from the world's own address, which is the one the
// campaign keeps under `settings.integrations.foundryUrl` — the icon window already loads
// the world's icons through it. The module sends the images it publishes as absolute URLs;
// the bridge's snapshot and older modules carry Foundry's relative paths, and a sheet
// reading one of those against Dragonroll's upload folder finds nothing, which is how the
// icons stopped loading (Syndria98/dragonroll#89). An absolute URL travels as it is, and so
// does a path when the campaign has no world address to read it against.
function worldAssetUrl(image, worldUrl) {
const value = String(image ?? '').trim();
if (!value || /^(https?:|data:|\/\/)/i.test(value)) return value;
return joinFoundryAssetUrl(worldUrl, value) || value;
}
// The images a world document arrives with, read against its world before they land.
function resolveWorldAssets(fields, campaign) {
const worldUrl = campaign?.settings?.integrations?.foundryUrl;
if (typeof fields.image === 'string') fields.image = worldAssetUrl(fields.image, worldUrl);
if (Array.isArray(fields.inventory)) {
for (const entry of fields.inventory) entry.icon = worldAssetUrl(entry.icon, worldUrl);
}
if (Array.isArray(fields.features)) {
for (const entry of fields.features) entry.icon = worldAssetUrl(entry.icon, worldUrl);
}
}
async function saveFoundryActor(campaign, source, fullSync = false, replace = false) {
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);
let actor = await Actor.findOne({ campaign: campaign._id, foundryActorId }); let actor = await Actor.findOne({ campaign: campaign._id, foundryActorId });
const dragonrollActorId = source?.flags?.['dragonroll-foundry']?.actorId; const dragonrollActorId = source?.flags?.['dragonroll-foundry']?.actorId;
@@ -85,6 +113,7 @@ async function saveFoundryItem(campaign, source, fullSync = false, folders = nul
const foundryItemId = String(source?._id || source?.id || '').trim().slice(0, 120); const foundryItemId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryItemToItemData(source || {}); const fields = foundryItemToItemData(source || {});
if (!foundryItemId || !fields) return null; if (!foundryItemId || !fields) return null;
resolveWorldAssets(fields, campaign);
let item = await Item.findOne({ campaign: campaign._id, foundryItemId }); let item = await Item.findOne({ campaign: campaign._id, foundryItemId });
const dragonrollItemId = source?.flags?.['dragonroll-foundry']?.itemId; const dragonrollItemId = source?.flags?.['dragonroll-foundry']?.itemId;
@@ -212,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;
@@ -243,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.
@@ -279,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;
@@ -355,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) => {
@@ -409,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

@@ -1,4 +1,5 @@
const { numberOr, asText, plainText, stringList } = require('./foundry-fields'); const { numberOr, asText, plainText, stringList } = require('./foundry-fields');
const { isFoundryGearType } = require('./item-foundry');
// D&D 5e keeps an actor's background, species, class and subclass as a reference to an // D&D 5e keeps an actor's background, species, class and subclass as a reference to an
// embedded item: `system.details.background` and friends hold that item's id, and the // embedded item: `system.details.background` and friends hold that item's id, and the
@@ -23,7 +24,121 @@ function detailsName(value, items) {
return looksLikeFoundryId(text) ? '' : text; return looksLikeFoundryId(text) ? '' : text;
} }
function foundryActorToCharacter(foundryActor) { // --- Skills, saving throws, tools, languages and coins (Syndria98/dragonroll#83) ---
// The eighteen skills a 5e character has, as the system keys them and as Dragonroll
// names them. The short keys mean nothing outside Foundry, and Dragonroll's sheet holds
// the names it shows a user.
const FOUNDRY_SKILLS = {
acr: 'acrobatics', ani: 'animalHandling', arc: 'arcana', ath: 'athletics', dec: 'deception',
his: 'history', ins: 'insight', itm: 'intimidation', inv: 'investigation', med: 'medicine',
nat: 'nature', prc: 'perception', perf: 'performance', prs: 'persuasion', rel: 'religion',
sle: 'sleightOfHand', stl: 'stealth', sur: 'survival'
};
const ABILITIES = ['str', 'dex', 'con', 'int', 'wis', 'cha'];
const CURRENCIES = ['pp', 'gp', 'ep', 'sp', 'cp'];
// Whether one of the system's proficiency fields says the character has that
// proficiency. The system has held it several ways across its releases — a boolean, a
// number of proficiency steps, a list of proficiency modes ('prof', 'exp'), or one of
// those under `value`, `proficient` or `prof` — and worlds run different releases of
// it. Anything above nothing counts as proficient.
function isProficient(value, depth = 0) {
if (value === undefined || value === null || depth > 3) return false;
if (typeof value === 'boolean') return value;
if (typeof value === 'number') return value > 0;
if (typeof value === 'string') {
const text = value.trim();
if (!text) return false;
const number = Number(text);
return Number.isFinite(number) ? number > 0 : text.toLowerCase() !== 'none';
}
if (Array.isArray(value)) return value.some((entry) => isProficient(entry, depth + 1));
return ['value', 'proficient', 'prof'].some((key) => isProficient(value[key], depth + 1));
}
// A toggled map (skill name or ability → proficient) from whatever the actor lists.
// `null` says the actor says nothing about them at all, which is what keeps a live
// Foundry edit from clearing the toggles the campaign set by hand.
function toggleMap(sources) {
const toggled = {};
for (const [name, value] of Object.entries(sources)) {
if (value !== undefined) toggled[name] = isProficient(value);
}
return Object.keys(toggled).length ? toggled : null;
}
function foundrySkills(system) {
const skills = system.skills && typeof system.skills === 'object' ? system.skills : {};
return toggleMap(Object.fromEntries(Object.entries(FOUNDRY_SKILLS)
.map(([key, name]) => [name, skills[key]])));
}
function foundrySavingThrows(system) {
const saves = system.saves && typeof system.saves === 'object' ? system.saves : {};
return toggleMap(Object.fromEntries(ABILITIES.map((key) => [
key,
system.savingThrows?.[key] ?? system.abilities?.[key]?.save ?? saves[key]
])));
}
// Tools and languages: the module sends the labels its own CONFIG holds, because a
// world's proficiency lists are keys — and, since the third system release, language
// documents — that mean nothing outside Foundry. Without them the keys are the best
// there is to name a proficiency with, and a bare Foundry document id is worse than
// nothing at all. `null` says the actor says nothing about the kind, `[]` that it has
// none of it. Dragonroll names its lists in full; the world keeps its tools under
// `system.traits.tool` and its languages under `system.traits.languages`.
const TRAIT_FIELDS = { tools: 'tool', languages: 'languages' };
function foundryTraitNames(actor, kind) {
const labels = actor.dragonroll?.[kind];
if (Array.isArray(labels)) {
return [...new Set(labels.map((label) => asText(label).trim()).filter(Boolean))];
}
const trait = actor.system?.traits?.[TRAIT_FIELDS[kind] ?? kind];
if (!trait || typeof trait !== 'object') return null;
const names = [
...stringList(trait.value),
...asText(trait.custom).split(',').map((name) => name.trim())
].filter((name) => name && !looksLikeFoundryId(name));
return [...new Set(names)];
}
function foundryCurrency(system) {
const coins = system.currency;
if (!coins || typeof coins !== 'object') return null;
return Object.fromEntries(CURRENCIES.map((key) => [key, Math.max(0, numberOr(coins[key], 0))]));
}
// The character's features: D&D 5e files species, background, class and monster features
// under the `feat` item type, each with its text and picture on the item. They are what
// the sheet's traits tab lists, one row per feature.
function foundryFeatures(items) {
return items
.filter((item) => item.type === 'feat')
.map((item) => ({
name: asText(item.name).trim(),
description: plainText(item.system?.description?.value ?? item.system?.description),
icon: asText(item.img).trim()
}))
.filter((feature) => feature.name);
}
// The free-form traits text: the details field some system releases keep, or what the
// campaign wrote and the module carries back on its flag. `undefined` says the world
// holds no text of its own, which keeps a live edit from clearing the campaign's.
function foundryTraits(source, savedDragonrollFields, replace) {
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 || {};
@@ -43,7 +158,7 @@ function foundryActorToCharacter(foundryActor) {
...stringList(traits.tool?.value) ...stringList(traits.tool?.value)
].join(', '); ].join(', ');
return { const fields = {
name: asText(foundryActor.name).trim(), name: asText(foundryActor.name).trim(),
type: ['character', 'npc', 'creature'].includes(savedDragonrollType) type: ['character', 'npc', 'creature'].includes(savedDragonrollType)
? savedDragonrollType ? savedDragonrollType
@@ -56,24 +171,65 @@ function foundryActorToCharacter(foundryActor) {
challengeRating: String(details.cr ?? ''), challengeRating: String(details.cr ?? ''),
description: plainText(details.biography?.value || details.biography), description: plainText(details.biography?.value || details.biography),
image: asText(foundryActor.img || foundryActor.image), image: asText(foundryActor.img || foundryActor.image),
abilityScores: Object.fromEntries(['str', 'dex', 'con', 'int', 'wis', 'cha'].map((key) => [ abilityScores: Object.fromEntries(ABILITIES.map((key) => [
key, key,
numberOr(abilities[key]?.value, 10) numberOr(abilities[key]?.value, 10)
])), ])),
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
traits: asText(savedDragonrollFields.traits), // 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
// 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: items inventory: items
.filter((item) => !['class', 'subclass', 'background', 'spell'].includes(item.type)) .filter((item) => isFoundryGearType(item.type))
.map((item) => ({ .map((item) => ({
name: asText(item.name).trim(), name: asText(item.name).trim(),
quantity: numberOr(item.system?.quantity, 1), quantity: numberOr(item.system?.quantity, 1),
weight: numberOr(item.system?.weight?.value ?? item.system?.weight, 0) weight: numberOr(item.system?.weight?.value ?? item.system?.weight, 0),
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
// out of the character is what keeps a live Foundry edit from clearing what the
// campaign toggled or wrote for it. Traits lead from the world when it has them, the
// way the proficiencies do; the text the module carries back on its flag is what the
// tab shows for an actor the world says nothing about.
const skills = foundrySkills(system);
if (skills) fields.skills = skills;
const savingThrows = foundrySavingThrows(system);
if (savingThrows) fields.savingThrows = savingThrows;
const tools = foundryTraitNames(foundryActor, 'tools');
if (tools) fields.tools = tools;
const languages = foundryTraitNames(foundryActor, 'languages');
if (languages) fields.languages = languages;
const currency = foundryCurrency(system);
if (currency) fields.currency = currency;
const worldTraits = foundryTraits(foundryActor, savedDragonrollFields, replace);
if (worldTraits) fields.traits = worldTraits;
// A replace writes the fields a live edit would leave out when the world says
// nothing, so the campaign's toggles, lists and text for this actor go with it and
// the row reads as the Foundry actor alone (Syndria98/dragonroll#96).
if (replace) {
if (fields.skills === undefined) fields.skills = {};
if (fields.savingThrows === undefined) fields.savingThrows = {};
if (fields.tools === undefined) fields.tools = [];
if (fields.languages === undefined) fields.languages = [];
if (fields.currency === undefined) fields.currency = {};
if (fields.traits === undefined) fields.traits = '';
}
return fields;
} }
module.exports = { foundryActorToCharacter }; module.exports = { foundryActorToCharacter };

View File

@@ -23,6 +23,14 @@ const NON_GEAR_FOUNDRY_TYPES = new Set([
'spell', 'class', 'subclass', 'background', 'feat', 'race', 'species', 'status', 'spellbook', 'language' 'spell', 'class', 'subclass', 'background', 'feat', 'race', 'species', 'status', 'spellbook', 'language'
]); ]);
// Whether a Foundry document of this type is gear: something a character carries. Traits,
// species, spells and the rest are documents of the world that mean something else on a
// Dragonroll sheet — a feat is a trait and a race is a species — so they stand in the
// character's own fields, never in its inventory (Syndria98/dragonroll#89).
function isFoundryGearType(type) {
return !NON_GEAR_FOUNDRY_TYPES.has(asText(type).toLowerCase().trim());
}
// Item categories the Dragonroll Item model accepts. // Item categories the Dragonroll Item model accepts.
const CATEGORIES = ['weapon', 'armor', 'shield', 'adventuring-gear', 'magic-item', 'consumable', 'tool', 'treasure', 'other']; const CATEGORIES = ['weapon', 'armor', 'shield', 'adventuring-gear', 'magic-item', 'consumable', 'tool', 'treasure', 'other'];
@@ -107,4 +115,4 @@ function foundryItemToItemData(foundryItem) {
}; };
} }
module.exports = { foundryItemToItemData }; module.exports = { foundryItemToItemData, isFoundryGearType };

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);
@@ -474,17 +612,65 @@ function serializeFoundryActor(actor) {
if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) { if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) {
data.img = new URL(data.img, window.location.origin).toString(); data.img = new URL(data.img, window.location.origin).toString();
} }
// Tools and languages travel by their names: what the actor holds are proficiency
// keys (and, since the third release of the system, language documents), which mean
// nothing to a sheet outside Foundry.
const names = { tools: foundryTraitNames(actor, "tools"), languages: foundryTraitNames(actor, "languages") };
if (names.tools || names.languages) data.dragonroll = { ...names };
return data; return data;
} }
// A proficiency list of `system.traits`: its keys resolved to the labels CONFIG gives
// them, plus whatever the GM typed as a proficiency of their own. `null` for an actor
// that has no such list, an empty array for one that has none of that kind. Dragonroll
// names its lists in full, while the world keeps its tools under `system.traits.tool`
// and its languages under `system.traits.languages`.
const TRAIT_FIELDS = { tools: "tool", languages: "languages" };
function foundryTraitNames(actor, kind) {
if (game.system?.id !== "dnd5e") return null;
const trait = actor.system?.traits?.[TRAIT_FIELDS[kind] ?? kind];
if (!trait || typeof trait !== "object") return null;
const names = (Array.isArray(trait.value) ? trait.value : [])
.map((key) => foundryProficiencyLabel(kind, key))
.filter(Boolean);
for (const custom of String(trait.custom ?? "").split(",")) {
const name = custom.trim();
if (name) names.push(name);
}
return [...new Set(names)];
}
function foundryProficiencyLabel(kind, key) {
if (typeof key !== "string" || !key) return "";
const entry = CONFIG.DND5E?.[kind === "languages" ? "languages" : "tools"]?.[key];
const label = entry?.label ?? entry?.name;
if (label) return String(label);
// A language the world added itself stands as a document of its own rather than in
// the system's config.
const document = kind === "languages" ? game.items?.get?.(key) : null;
if (document?.name) return String(document.name);
// The key beats dropping a proficiency the character really has.
return key;
}
function isSupportedCharacterActor(actor) { function isSupportedCharacterActor(actor) {
const savedType = actor.getFlag?.(MODULE_ID, "actorType") || actor.flags?.[MODULE_ID]?.actorType; const savedType = actor.getFlag?.(MODULE_ID, "actorType") || actor.flags?.[MODULE_ID]?.actorType;
return ["character", "npc", "creature"].includes(savedType || actor.type); return ["character", "npc", "creature"].includes(savedType || actor.type);
} }
// Embedded documents the world owns outright (Syndria98/dragonroll#89): a feat is a trait
// and a race is a species — they reach the campaign through its traits and species fields,
// never through its inventory. Dragonroll must neither mark them as its own nor delete one
// when it writes the character, and an older campaign still holding such a row in its
// inventory must be let to write it out of the campaign without the document going with it.
const WORLD_OWNED_EMBEDDED_TYPES = new Set(["feat", "race", "species", "status", "spellbook", "language"]);
async function markActorItemsAsSynced(actor) { async function markActorItemsAsSynced(actor) {
const updates = actor.items.contents const updates = actor.items.contents
.filter((item) => !item.getFlag?.(MODULE_ID, "syncedItem")) .filter((item) => !item.getFlag?.(MODULE_ID, "syncedItem") && !WORLD_OWNED_EMBEDDED_TYPES.has(item.type))
.map((item) => ({ .map((item) => ({
_id: item.id, _id: item.id,
[`flags.${MODULE_ID}.syncedItem`]: true, [`flags.${MODULE_ID}.syncedItem`]: true,
@@ -518,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") {
@@ -537,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 || []) {
@@ -559,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()) {
@@ -576,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.`);
@@ -616,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;
@@ -722,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 || "";
@@ -870,423 +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"));
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))
.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);
} }
} }
@@ -1382,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",
@@ -1403,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;
} }
@@ -1423,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

@@ -417,4 +417,89 @@ 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-name">{{ row.item.name }}</span> <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>
<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,9 +804,12 @@ 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-name-row"> <span class="entity-entry-title">
<span class="entity-entry-name">{{ row.item.name }}</span> <img class="entity-entry-icon" src="/icons/iconoir/regular/map.svg" alt="" aria-hidden="true">
<span v-if="isAnchoredMap(row.item)" class="entity-entry-sync">{{ t('campaigns.map.anchored') }}</span> <span class="entity-entry-name-row">
<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>
</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>
@@ -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,6 +42,11 @@ function ExitCampaign() {
<TopSearchBar></TopSearchBar> <TopSearchBar></TopSearchBar>
</div> </div>
<div class="right"> <div class="right">
<!-- La documentació s'obre en una finestra seva, davant de la campanya: les notes
obertes no es perden i no cal obrir una pestanya nova. -->
<button class="btn-primary settings-button docs-button sound-click" type="button" @click="OpenDocumentation">
{{ $t('main-menu.documentation') }}
</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>

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

@@ -436,6 +436,14 @@ async function onTokenPointerUp(event) {
await placeToken(token.actor, { x, y }); await placeToken(token.actor, { x, y });
} }
// Double clicking a token (or Enter on a focused one) opens the sheet of the actor it stands for.
// A single click cannot be the trigger: the click that ends a drag lands on the token too, so
// dragging a token over the map would open its sheet every time.
function openTokenSheet(token) {
const actor = tokenActor(token);
if (actor) openActorSheet(actor);
}
const CELL_STEPS = { const CELL_STEPS = {
ArrowLeft: [-1, 0], ArrowLeft: [-1, 0],
ArrowRight: [1, 0], ArrowRight: [1, 0],
@@ -443,7 +451,8 @@ const CELL_STEPS = {
ArrowDown: [0, 1] ArrowDown: [0, 1]
}; };
// A focused token answers to the keyboard too: arrows walk it over the grid, Delete takes it off. // A focused token answers to the keyboard too: arrows walk it over the grid, Delete takes it off
// and Enter opens its sheet, the way a double click does.
async function onTokenKeydown(event, token) { async function onTokenKeydown(event, token) {
const step = CELL_STEPS[event.key]; const step = CELL_STEPS[event.key];
if (step) { if (step) {
@@ -456,6 +465,7 @@ async function onTokenKeydown(event, token) {
event.preventDefault(); event.preventDefault();
await removeToken(token); await removeToken(token);
} }
if (event.key === 'Enter') openTokenSheet(token);
} }
function onTokenContextMenu(token) { function onTokenContextMenu(token) {
@@ -609,6 +619,7 @@ onBeforeUnmount(() => {
@pointermove="onTokenPointerMove" @pointermove="onTokenPointerMove"
@pointerup="onTokenPointerUp" @pointerup="onTokenPointerUp"
@pointercancel="onTokenPointerUp" @pointercancel="onTokenPointerUp"
@dblclick="openTokenSheet(token)"
@contextmenu.stop.prevent="onTokenContextMenu(token)" @contextmenu.stop.prevent="onTokenContextMenu(token)"
@keydown="onTokenKeydown($event, token)" @keydown="onTokenKeydown($event, token)"
> >

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

@@ -108,11 +108,13 @@ useHead({
color: var(--color-text); color: var(--color-text);
} }
/* Els dos aside fan la pàgina sencera avall: amb alçada d'una pantalla i enganxats a
dalt, el fons i la vora arriben sempre fins a baix, per molt llarg que sigui el text. */
.docs-sidebar, .docs-sidebar,
.docs-sections { .docs-sections {
position: sticky; position: sticky;
top: 0; top: 0;
max-height: 100vh; height: 100vh;
overflow-y: auto; overflow-y: auto;
box-sizing: border-box; box-sizing: border-box;
padding: 18px 14px; padding: 18px 14px;
@@ -122,7 +124,6 @@ useHead({
flex: 0 0 268px; flex: 0 0 268px;
width: 268px; width: 268px;
border-right: 1px solid var(--color-border); border-right: 1px solid var(--color-border);
background-color: var(--color-background-light);
display: flex; display: flex;
flex-direction: column; flex-direction: column;
gap: 14px; gap: 14px;
@@ -208,8 +209,13 @@ useHead({
box-sizing: border-box; box-sizing: border-box;
} }
.docs-article { /* La columna de lectura, centrada dins l'espai que deixa la barra lateral: en una finestra
ampla el text queda al mig, no enganxat a l'esquerra. */
.docs-article,
.docs-pager {
width: 100%;
max-width: 760px; max-width: 760px;
margin-inline: auto;
} }
.docs-kicker { .docs-kicker {
@@ -221,7 +227,6 @@ useHead({
} }
.docs-pager { .docs-pager {
max-width: 760px;
margin-top: 34px; margin-top: 34px;
padding-top: 18px; padding-top: 18px;
border-top: 1px solid var(--color-border); border-top: 1px solid var(--color-border);
@@ -256,8 +261,10 @@ useHead({
} }
.docs-sections { .docs-sections {
flex: 0 0 220px; flex: 0 0 240px;
width: 220px; width: 240px;
/* Més aire al voltant dels apartats, que ara mateix van clavats a la vora. */
padding: 26px 22px 26px 18px;
border-left: 1px solid var(--color-border); border-left: 1px solid var(--color-border);
} }
@@ -294,87 +301,19 @@ 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) { /* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del
margin: 30px 0 10px 0; text en lloc d'estirats cap al cantó dret de la pantalla. */
padding-bottom: 4px; @media (min-width: 1440px) {
border-bottom: 1px solid var(--color-border); .docs {
font-family: 'MrEavesRemake', serif; justify-content: center;
font-size: 1.35rem; }
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown :deep(h3) { .docs-main {
margin: 22px 0 8px 0; flex: 0 1 860px;
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);
} }
@media (max-width: 1200px) { @media (max-width: 1200px) {
@@ -391,7 +330,7 @@ useHead({
.docs-sidebar, .docs-sidebar,
.docs-sections { .docs-sections {
position: static; position: static;
max-height: none; height: auto;
width: 100%; width: 100%;
border-left: none; border-left: none;
border-right: none; border-right: none;

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';
@@ -24,6 +24,23 @@ const abilityStats = [
{ key: 'int', label: 'INT' }, { key: 'wis', label: 'WIS' }, { key: 'cha', label: 'CHA' } { key: 'int', label: 'INT' }, { key: 'wis', label: 'WIS' }, { key: 'cha', label: 'CHA' }
]; ];
// Les habilitats del 5e. Cada una té un cercle que s'encén quan el personatge hi és
// proficient, i la modificadora que tira és la de la característica que mana.
const skillList = [
{ key: 'acrobatics', ability: 'dex' }, { key: 'animalHandling', ability: 'wis' },
{ key: 'arcana', ability: 'int' }, { key: 'athletics', ability: 'str' },
{ key: 'deception', ability: 'cha' }, { key: 'history', ability: 'int' },
{ key: 'insight', ability: 'wis' }, { key: 'intimidation', ability: 'cha' },
{ key: 'investigation', ability: 'int' }, { key: 'medicine', ability: 'wis' },
{ key: 'nature', ability: 'int' }, { key: 'perception', ability: 'wis' },
{ key: 'performance', ability: 'cha' }, { key: 'persuasion', ability: 'cha' },
{ key: 'religion', ability: 'int' }, { key: 'sleightOfHand', ability: 'dex' },
{ key: 'stealth', ability: 'dex' }, { key: 'survival', ability: 'wis' }
];
// Les cinc monedes que un personatge porta al damunt.
const currencyUnits = ['pp', 'gp', 'ep', 'sp', 'cp'];
// Les pestanyes del lateral dret reparteixen la fitxa: característiques i combat, // Les pestanyes del lateral dret reparteixen la fitxa: característiques i combat,
// inventari, trets i conjurs. Són pestanyes de marcadors, no una pàgina nova. // inventari, trets i conjurs. Són pestanyes de marcadors, no una pàgina nova.
const tabs = [ const tabs = [
@@ -39,6 +56,17 @@ const activeTab = ref('abilities');
// per sota de 760px el marc les fa estar a dins i el marge deixa de fer falta. // per sota de 760px el marc les fa estar a dins i el marge deixa de fer falta.
const TAB_RAIL_WIDTH = 150; const TAB_RAIL_WIDTH = 150;
// Les eines i els idiomes viatgen com a llista i el formulari els edita com un quadre
// de text: un nom per línia. Les comes també separen, que és com s'escriuen en una frase.
function proficiencyText(value) {
const names = Array.isArray(value) ? value : String(value ?? '').split(/[\n,]/);
return [...new Set(names.map((name) => String(name).trim()).filter(Boolean))].join('\n');
}
function proficiencyList(text) {
return [...new Set(String(text ?? '').split(/[\n,]/).map((name) => String(name).trim()).filter(Boolean))];
}
function normalizeActor(actor) { function normalizeActor(actor) {
return { return {
name: actor?.name ?? '', name: actor?.name ?? '',
@@ -60,8 +88,22 @@ function normalizeActor(actor) {
max: Number(actor?.hitDice?.max ?? actor?.level ?? 1) max: Number(actor?.hitDice?.max ?? actor?.level ?? 1)
}, },
proficiencies: actor?.proficiencies ?? '', proficiencies: actor?.proficiencies ?? '',
// El que el personatge sap fer i el que porta: les habilitats i les tirades de
// salvació són cercles que s'encenen, les eines i els idiomes són noms que el
// formulari edita com un text d'una línia per nom, i la moneda són cinc xifres.
skills: Object.fromEntries(skillList.map(({ key }) => [key, Boolean(actor?.skills?.[key])])),
savingThrows: Object.fromEntries(abilityStats.map(({ key }) => [key, Boolean(actor?.savingThrows?.[key])])),
tools: proficiencyText(actor?.tools),
languages: proficiencyText(actor?.languages),
currency: Object.fromEntries(currencyUnits.map((unit) => [unit, Number(actor?.currency?.[unit] ?? 0) || 0])),
inventory: (actor?.inventory ?? []).map((item) => ({ inventory: (actor?.inventory ?? []).map((item) => ({
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 ?? ''
})),
// 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 ?? '',
@@ -110,17 +152,37 @@ const carryingCapacity = computed(() => form.value.abilityScores.str * 15);
const carriedWeight = computed(() => form.value.inventory.reduce((total, item) => total + (Number(item.quantity) || 0) * (Number(item.weight) || 0), 0)); const carriedWeight = computed(() => form.value.inventory.reduce((total, item) => total + (Number(item.quantity) || 0) * (Number(item.weight) || 0), 0));
const carryPercent = computed(() => Math.min(100, carryingCapacity.value ? (carriedWeight.value / carryingCapacity.value) * 100 : 0)); const carryPercent = computed(() => Math.min(100, carryingCapacity.value ? (carriedWeight.value / carryingCapacity.value) * 100 : 0));
function abilityModifier(score) { // `bonus` és el bonificador de proficiència, per a les habilitats i les tirades de
const modifier = Math.floor((Number(score) - 10) / 2); // salvació del personatge que hi està entrenat.
function abilityModifier(score, bonus = 0) {
const modifier = Math.floor((Number(score) - 10) / 2) + (Number(bonus) || 0);
return modifier >= 0 ? `+${modifier}` : String(modifier); return modifier >= 0 ? `+${modifier}` : String(modifier);
} }
const imageUrl = computed(() => { function skillModifier(skill) {
if (!form.value.image) return ''; return abilityModifier(form.value.abilityScores[skill.ability], form.value.skills[skill.key] ? proficiencyBonus.value : 0);
return /^(https?:|data:|\/\/)/i.test(form.value.image) }
? form.value.image
: `${getBaseUrl()}/public/${form.value.image}`; function savingThrowModifier(stat) {
}); return abilityModifier(form.value.abilityScores[stat.key], form.value.savingThrows[stat.key] ? proficiencyBonus.value : 0);
}
// El cercle d'una habilitat o d'una salvació: s'encén i s'apaga, i es desa amb tota la
// fitxa, com la resta del que s'edita.
function toggleProficiency(group, key) {
form.value[group][key] = !form.value[group][key];
}
// Una imatge pot ser una adreça sencera (la que Foundry dona a un objecte, per
// exemple) o un fitxer pujat aquí, que es serveix per `/api/public`.
function resolveImage(image) {
if (!image) return '';
return /^(https?:|data:|\/\/)/i.test(image)
? image
: `${getBaseUrl()}/public/${image}`;
}
const imageUrl = computed(() => resolveImage(form.value.image));
function pickPhoto() { function pickPhoto() {
photoInput.value?.click(); photoInput.value?.click();
@@ -176,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;
@@ -184,6 +254,9 @@ async function saveSheet() {
const payload = { const payload = {
id: actorId, id: actorId,
...form.value, ...form.value,
// Les eines i els idiomes van a l'API com a llista, que és com està desats.
tools: proficiencyList(form.value.tools),
languages: proficiencyList(form.value.languages),
inventory: form.value.inventory.filter((item) => item.name.trim()) inventory: form.value.inventory.filter((item) => item.name.trim())
}; };
const response = await Server().post('/actor/update', payload); const response = await Server().post('/actor/update', payload);
@@ -259,7 +332,10 @@ async function saveSheet() {
<div v-if="error" class="sheet-error">{{ error }}</div> <div v-if="error" class="sheet-error">{{ error }}</div>
<main v-show="activeTab === 'abilities'" class="sheet-grid"> <!-- La columna del personatge no penja de cap pestanya: la imatge i el que es mira
d'anada i tornada — classe d'armadura, velocitat, bonificadors i les barres de
cops — es queden a la vista des de qualsevol pestanya de la fitxa. -->
<div class="sheet-layout">
<div class="character-column"> <div class="character-column">
<div v-if="form.image || editing" class="sheet-portrait" :class="{ empty: !form.image }"> <div v-if="form.image || editing" class="sheet-portrait" :class="{ empty: !form.image }">
<img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.character-sheet.photo')"> <img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.character-sheet.photo')">
@@ -327,75 +403,160 @@ async function saveSheet() {
</section> </section>
</div> </div>
<section class="sheet-panel abilities-panel"> <main v-show="activeTab === 'abilities'" class="sheet-tab-body">
<h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2> <section class="sheet-panel abilities-panel">
<div class="ability-grid"> <h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2>
<div v-for="stat in abilityStats" :key="stat.key" class="ability-card"> <div class="ability-grid">
<span class="ability-label">{{ stat.label }}</span> <div v-for="stat in abilityStats" :key="stat.key" class="ability-card">
<input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label"> <span class="ability-label">{{ stat.label }}</span>
<strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong> <input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label">
<span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span> <strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong>
<span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span>
</div>
</div> </div>
</div>
</section>
<section class="sheet-panel proficiencies-panel"> <!-- Les tirades de salvació van just a sota de les característiques, que
<h2>{{ $t('campaigns.character-sheet.proficiencies') }}</h2> són les que les manen: el cercle diu si el personatge hi està entrenat. -->
<textarea v-if="editing" v-model="form.proficiencies" rows="7" :placeholder="$t('campaigns.character-sheet.proficiencies-placeholder')" /> <h3>{{ $t('campaigns.character-sheet.saving-throws') }}</h3>
<p v-else class="sheet-copy">{{ form.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p> <div class="saving-throw-grid">
</section> <button
</main> v-for="stat in abilityStats"
:key="stat.key"
class="proficiency-row"
type="button"
role="switch"
:aria-checked="form.savingThrows[stat.key]"
:disabled="!editing"
@click="toggleProficiency('savingThrows', stat.key)"
>
<span class="proficiency-dot" :class="{ proficient: form.savingThrows[stat.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.abilities.${stat.key}`) }}</span>
<span class="proficiency-modifier">{{ savingThrowModifier(stat) }}</span>
</button>
</div>
</section>
<main v-show="activeTab === 'inventory'" class="sheet-tab-body"> <section class="sheet-panel skills-panel">
<section class="sheet-panel inventory-panel"> <h2>{{ $t('campaigns.character-sheet.skills') }}</h2>
<div class="panel-title-row"> <div class="skill-grid">
<h2>{{ $t('campaigns.character-sheet.inventory') }}</h2> <button
<button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button> v-for="skill in skillList"
</div> :key="skill.key"
<div class="weight-summary"> class="proficiency-row"
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span> type="button"
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong> role="switch"
</div> :aria-checked="form.skills[skill.key]"
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div> :disabled="!editing"
<div class="inventory-table-wrap"> @click="toggleProficiency('skills', skill.key)"
<table class="inventory-table"> >
<thead><tr> <span class="proficiency-dot" :class="{ proficient: form.skills[skill.key] }" aria-hidden="true" />
<th>{{ $t('campaigns.character-sheet.item-name') }}</th> <span class="proficiency-name">{{ $t(`campaigns.character-sheet.skill-names.${skill.key}`) }}</span>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th> <span class="proficiency-ability">{{ skill.ability.toUpperCase() }}</span>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th> <span class="proficiency-modifier">{{ skillModifier(skill) }}</span>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th> </button>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th> </div>
</tr></thead> </section>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 5 : 4" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body"> <section class="sheet-panel proficiencies-panel">
<section class="sheet-panel traits-panel"> <h2>{{ $t('campaigns.character-sheet.proficiencies') }}</h2>
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2> <textarea v-if="editing" v-model="form.proficiencies" rows="7" :placeholder="$t('campaigns.character-sheet.proficiencies-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.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p>
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p>
</section>
</main>
<main v-show="activeTab === 'spells'" class="sheet-tab-body"> <!-- Les eines i els idiomes tenen llista pròpia; el text de dalt guarda
<section class="sheet-panel spells-panel"> el que no en té, com les armadures i les armes. -->
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2> <div class="proficiency-lists">
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" /> <div class="proficiency-list">
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p> <h3>{{ $t('campaigns.character-sheet.tools') }}</h3>
</section> <textarea v-if="editing" v-model="form.tools" rows="4" :placeholder="$t('campaigns.character-sheet.tools-placeholder')" />
</main> <p v-else class="sheet-copy">{{ form.tools || $t('campaigns.character-sheet.empty-tools') }}</p>
</div>
<div class="proficiency-list">
<h3>{{ $t('campaigns.character-sheet.languages') }}</h3>
<textarea v-if="editing" v-model="form.languages" rows="4" :placeholder="$t('campaigns.character-sheet.languages-placeholder')" />
<p v-else class="sheet-copy">{{ form.languages || $t('campaigns.character-sheet.empty-languages') }}</p>
</div>
</div>
</section>
</main>
<main v-show="activeTab === 'inventory'" class="sheet-tab-body">
<section class="sheet-panel inventory-panel">
<div class="panel-title-row">
<h2>{{ $t('campaigns.character-sheet.inventory') }}</h2>
<button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button>
</div>
<div class="weight-summary">
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span>
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong>
</div>
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div>
<!-- La moneda que el personatge porta a sobre, en les cinc monedes del joc. -->
<h3>{{ $t('campaigns.character-sheet.currency') }}</h3>
<div class="currency-row">
<label v-for="unit in currencyUnits" :key="unit" class="currency-field">
<span>{{ $t(`campaigns.character-sheet.currency-units.${unit}`) }}</span>
<input v-if="editing" v-model.number="form.currency[unit]" type="number" min="0" :aria-label="$t(`campaigns.character-sheet.currency-units.${unit}`)">
<strong v-else>{{ form.currency[unit] }}</strong>
</label>
</div>
<div class="inventory-table-wrap">
<table class="inventory-table">
<thead><tr>
<th><span class="sr-only">{{ $t('campaigns.character-sheet.item-icon') }}</span></th>
<th class="item-name-cell">{{ $t('campaigns.character-sheet.item-name') }}</th>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th>
</tr></thead>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td class="item-icon-cell">
<img v-if="item.icon" :src="resolveImage(item.icon)" :alt="$t('campaigns.character-sheet.item-icon')">
<span v-else class="item-icon-blank" aria-hidden="true" />
</td>
<td class="item-name-cell"><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 6 : 5" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body">
<section class="sheet-panel traits-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2>
<!-- Una capacitat per filera, amb la icona a l'esquerra com l'inventari;
clicar-la obre la seva descripció. -->
<div v-if="form.features.length" class="trait-list">
<button v-for="(trait, index) in form.features" :key="index" class="trait-row" type="button" @click="openTrait(trait)">
<span class="trait-icon-cell">
<img v-if="trait.icon" :src="resolveImage(trait.icon)" alt="">
<span v-else class="item-icon-blank" aria-hidden="true" />
</span>
<span class="trait-name">{{ trait.name }}</span>
</button>
</div>
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" />
<p v-else-if="form.traits" class="sheet-copy">{{ form.traits }}</p>
<p v-else-if="!form.features.length" class="sheet-copy">{{ $t('campaigns.character-sheet.empty-traits') }}</p>
</section>
</main>
<main v-show="activeTab === 'spells'" class="sheet-tab-body">
<section class="sheet-panel spells-panel">
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2>
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" />
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p>
</section>
</main>
</div>
</div> </div>
</div> </div>
</template> </template>
@@ -419,8 +580,10 @@ async function saveSheet() {
.sheet-button.primary { background: var(--color-link); color: var(--color-background); border-color: var(--color-link); } .sheet-button.primary { background: var(--color-link); color: var(--color-background); border-color: var(--color-link); }
.sheet-button:disabled { opacity: .55; cursor: wait; } .sheet-button:disabled { opacity: .55; cursor: wait; }
.sheet-button.compact { padding: 5px 9px; font-size: 12px; } .sheet-button.compact { padding: 5px 9px; font-size: 12px; }
.sheet-grid { display: grid; grid-template-columns: minmax(200px, 34%) minmax(0, 1fr) minmax(0, 1fr); grid-template-rows: auto auto; gap: 11px; align-items: start; } /* El marc de la fitxa: la columna del personatge, sempre a la vista, i al seu costat el contingent
.sheet-tab-body { display: block; } de la pestanya oberta. */
.sheet-layout { display: grid; grid-template-columns: minmax(200px, 34%) minmax(0, 1fr); gap: 11px; align-items: start; }
.sheet-tab-body { grid-column: 2; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
/* Pestilletes del marc: arrencen del cantó dret de la finestra, per fora del cos, i queden /* Pestilletes del marc: arrencen del cantó dret de la finestra, per fora del cos, i queden
fora del contingent que desfila. Per sota de 760px no hi ha lloc fora (vegeu a sota). */ fora del contingent que desfila. Per sota de 760px no hi ha lloc fora (vegeu a sota). */
.sheet-tabs { position: absolute; left: 100%; top: 34px; display: flex; flex-direction: column; align-items: flex-start; gap: 5px; padding-top: 6px; } .sheet-tabs { position: absolute; left: 100%; top: 34px; display: flex; flex-direction: column; align-items: flex-start; gap: 5px; padding-top: 6px; }
@@ -454,16 +617,28 @@ async function saveSheet() {
.portrait-controls button:disabled { opacity: .55; cursor: wait; } .portrait-controls button:disabled { opacity: .55; cursor: wait; }
.photo-input { display: none; } .photo-input { display: none; }
/* La columna de la fitxa: la imatge dalt i, just a sota, el que es consulta d'anada i /* La columna de la fitxa: la imatge dalt i, just a sota, el que es consulta d'anada i
tornada — classe d'armadura, velocitat, bonificadors i les barres de cops. */ tornada — classe d'armadura, velocitat, bonificadors i les barres de cops. No penja de
.character-column { grid-column: 1; grid-row: 1 / -1; display: flex; flex-direction: column; gap: 11px; min-width: 0; } cap pestanya: es queda al seu lloc mentre se'n canvia. */
.abilities-panel { grid-column: 2 / -1; grid-row: 1; } .character-column { grid-column: 1; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
.proficiencies-panel { grid-column: 2 / -1; grid-row: 2; }
.ability-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 7px; } .ability-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 7px; }
.ability-card { min-height: 83px; padding: 8px 5px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 3px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); } .ability-card { min-height: 83px; padding: 8px 5px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 3px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); }
.ability-label { font-size: 11px; font-weight: 700; letter-spacing: .08em; opacity: .75; } .ability-label { font-size: 11px; font-weight: 700; letter-spacing: .08em; opacity: .75; }
.ability-score { font: 25px MrEavesRemake; } .ability-score { font: 25px MrEavesRemake; }
.ability-modifier { min-width: 33px; text-align: center; padding: 2px 5px; border-radius: 999px; background: var(--color-background); font-size: 12px; } .ability-modifier { min-width: 33px; text-align: center; padding: 2px 5px; border-radius: 999px; background: var(--color-background); font-size: 12px; }
.ability-card input { width: 55px; text-align: center; font-size: 21px; } .ability-card input { width: 55px; text-align: center; font-size: 21px; }
/* Les habilitats i les tirades de salvació: el cercle diu si el personatge hi està
entrenat, al costat la característica que mana i la modificadora que tira. */
.saving-throw-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 5px; }
.skill-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 5px; }
.proficiency-row { display: flex; align-items: center; gap: 6px; min-width: 0; padding: 5px 7px; border: 1px solid var(--color-border); border-radius: 7px; background: var(--color-background-soft); color: var(--color-text); font: inherit; font-size: 12px; text-align: left; cursor: pointer; }
.proficiency-row:hover:not(:disabled) { border-color: var(--color-link); }
.proficiency-row:disabled { cursor: default; }
.proficiency-dot { width: 14px; height: 14px; flex: 0 0 14px; border: 2px solid var(--color-border); border-radius: 50%; }
.proficiency-dot.proficient { border-color: var(--color-link); background: var(--color-link); box-shadow: inset 0 0 0 2px var(--color-background-soft); }
.proficiency-name { flex: 1; min-width: 0; overflow-wrap: anywhere; }
.proficiency-ability { font-size: 10px; letter-spacing: .06em; opacity: .6; }
.proficiency-modifier { font-size: 11px; opacity: .8; }
.proficiency-lists { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 11px; }
.vitals-panel { display: flex; flex-direction: column; gap: 11px; } .vitals-panel { display: flex; flex-direction: column; gap: 11px; }
.vital-stats { display: grid; grid-template-columns: 1fr 1fr; gap: 7px; } .vital-stats { display: grid; grid-template-columns: 1fr 1fr; gap: 7px; }
.vital-stat { min-height: 68px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 4px; padding: 6px 4px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); text-align: center; } .vital-stat { min-height: 68px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 4px; padding: 6px 4px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); text-align: center; }
@@ -486,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; }
@@ -495,20 +680,31 @@ textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.weight-track { height: 5px; margin-bottom: 10px; overflow: hidden; border-radius: 999px; background: var(--color-background-soft); } .weight-track { height: 5px; margin-bottom: 10px; overflow: hidden; border-radius: 999px; background: var(--color-background-soft); }
.weight-fill { height: 100%; border-radius: inherit; background: var(--color-link); transition: width .2s ease; } .weight-fill { height: 100%; border-radius: inherit; background: var(--color-link); transition: width .2s ease; }
.inventory-table-wrap { overflow-x: auto; } .inventory-table-wrap { overflow-x: auto; }
/* La moneda que el personatge porta a sobre, en les cinc del joc. */
.currency-row { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 7px; margin-bottom: 11px; }
.currency-field { display: flex; flex-direction: column; align-items: center; gap: 3px; padding: 6px 4px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); text-align: center; }
.currency-field > span { font-size: 10px; letter-spacing: .05em; opacity: .72; }
.currency-field > strong { font: 15px MrEavesRemake; }
.currency-field input { width: 58px; text-align: center; }
.inventory-table { width: 100%; border-collapse: collapse; font-size: 12px; } .inventory-table { width: 100%; border-collapse: collapse; font-size: 12px; }
.inventory-table th { padding: 6px 7px; text-align: left; font-weight: 600; opacity: .7; } .inventory-table th { padding: 6px 7px; text-align: left; font-weight: 600; opacity: .7; }
.inventory-table td { padding: 5px 7px; border-top: 1px solid var(--color-border); } .inventory-table td { padding: 5px 7px; border-top: 1px solid var(--color-border); }
.inventory-table td input { width: 100%; min-width: 54px; } .inventory-table td input { width: 100%; min-width: 54px; }
.inventory-table td:first-child input { min-width: 100px; } .inventory-table td.item-name-cell input { min-width: 100px; }
.inventory-table th:not(:first-child), .inventory-table td:not(:first-child) { text-align: center; } /* La icona de cada objecte obre la filera; el nom continua alineat a l'esquerra i la
quantitat i els pesos van al centre. */
.inventory-table .item-icon-cell { width: 40px; padding-right: 0; }
.item-icon-cell img { display: block; width: 26px; height: 26px; object-fit: contain; border-radius: 5px; }
.item-icon-blank { display: block; width: 26px; height: 26px; border: 1px dashed var(--color-border); border-radius: 5px; opacity: .35; }
.inventory-table th:not(:first-child):not(.item-name-cell), .inventory-table td:not(:first-child):not(.item-name-cell) { text-align: center; }
.empty-inventory { text-align: center !important; opacity: .65; } .empty-inventory { text-align: center !important; opacity: .65; }
.remove-item { width: 24px; height: 24px; border: 0; border-radius: 5px; background: transparent; color: var(--color-text); font-size: 20px; cursor: pointer; } .remove-item { width: 24px; height: 24px; border: 0; border-radius: 5px; background: transparent; color: var(--color-text); font-size: 20px; cursor: pointer; }
.remove-item:hover { background: var(--color-button-hover); } .remove-item:hover { background: var(--color-button-hover); }
.sheet-error { padding: 7px 10px; margin-bottom: 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; } .sheet-error { padding: 7px 10px; margin-bottom: 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; }
.sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; } .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
@media (max-width: 760px) { @media (max-width: 760px) {
.sheet-grid { grid-template-columns: 1fr; grid-template-rows: none; } .sheet-layout { grid-template-columns: 1fr; }
.character-column, .abilities-panel, .proficiencies-panel { grid-column: 1 / -1; grid-row: auto; } .character-column, .sheet-tab-body { grid-column: 1 / -1; grid-row: auto; }
/* El cantó dret no dona prou per penjar-hi les pestanyes: llavors es queden al marc, per /* El cantó dret no dona prou per penjar-hi les pestanyes: llavors es queden al marc, per
dins, en una filera sota la barra de la finestra. */ dins, en una filera sota la barra de la finestra. */
.sheet-tabs { position: static; align-self: stretch; flex-direction: row; flex-wrap: wrap; gap: 4px; padding: 6px 8px 0; } .sheet-tabs { position: static; align-self: stretch; flex-direction: row; flex-wrap: wrap; gap: 4px; padding: 6px 8px 0; }
@@ -519,5 +715,7 @@ textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.sheet-hero { align-items: flex-start; flex-wrap: wrap; } .sheet-hero { align-items: flex-start; flex-wrap: wrap; }
.sheet-actions { margin-left: auto; } .sheet-actions { margin-left: auto; }
.ability-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); } .ability-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); }
.skill-grid, .saving-throw-grid, .proficiency-lists { grid-template-columns: 1fr; }
.currency-row { grid-template-columns: repeat(3, minmax(0, 1fr)); }
} }
</style> </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';
@@ -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
@@ -14,11 +14,14 @@ Opening an actor opens its **character sheet**, in tabs:
| Tab | What it holds | | Tab | What it holds |
| --- | --- | | --- | --- |
| Ability Scores | Strength, Dexterity, Constitution, Intelligence, Wisdom, Charisma, and the proficiency bonus | | Ability Scores | Strength, Dexterity, Constitution, Intelligence, Wisdom, Charisma, and the proficiency bonus. Under them the six saving throws and the eighteen skills, each with a circle that stands lit when the character is proficient with it, next to the modifier it rolls. The proficiencies follow: the character's tools, its languages, and whatever else it is proficient with as text |
| Inventory | What it carries: item, quantity and weight each, with the total carried weight added up | | Inventory | What it carries: every item with its icon, quantity and weight each, the total carried weight added up, and the coins the character holds |
| Traits | Features, traits and other details, as text | | Traits | Features, traits and other details, as text |
| Spells | The spells it knows, one per line | | Spells | The spells it knows, one per line |
Toggling a skill, a saving throw, or writing a tool or a language is done like everything else on the
sheet: **Edit**, change it, **Save sheet**.
Combat lives above the tabs: armor class, speed, initiative, current and maximum hit points, and hit Combat lives above the tabs: armor class, speed, initiative, current and maximum hit points, and hit
dice. The photo at the top of the sheet is what shows up next to the character everywhere else — dice. The photo at the top of the sheet is what shows up next to the character everywhere else —
including in [Discord](/docs/discord), where players can read the sheet of the character they hold. including in [Discord](/docs/discord), where players can read the sheet of the character they hold.

View File

@@ -44,8 +44,8 @@ cell you dropped it on and is sized by that cell, so a huge creature can be give
sizing it up on the map's settings. sizing it up on the map's settings.
Once a token is on the map you can drag it to another cell, step it across the grid one cell at a time Once a token is on the map you can drag it to another cell, step it across the grid one cell at a time
with the **arrow keys**, and take it off with **Delete**. Clicking a token opens the sheet of the actor with the **arrow keys**, and take it off with **Delete**. Double-clicking a token opens the sheet of
it stands for. the actor it stands for, and **Enter** does the same on a token focused with the keyboard.
Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a
token off does not remove the character from the campaign. token off does not remove the character from the campaign.

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
@@ -47,10 +53,10 @@ Worth knowing:
| In Foundry | In the campaign | | In Foundry | In the campaign |
| --- | --- | | --- | --- |
| Character, NPC and creature actors | Actors with the same sheet: abilities, combat stats, proficiencies, traits, spells, carried gear, 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" },
@@ -120,10 +127,22 @@
"saving": "Desant...", "save": "Desa la fitxa", "save-error": "No s'ha pogut desar aquesta fitxa de personatge.", "photo": "Foto", "upload-photo": "Pujar foto", "change-photo": "Canviar foto", "remove-photo": "Treure foto", "uploading-photo": "Pujant...", "photo-error": "No s'ha pogut pujar aquesta foto.", "ability-scores": "Característiques", "proficiency-bonus": "Bonificador de competència", "saving": "Desant...", "save": "Desa la fitxa", "save-error": "No s'ha pogut desar aquesta fitxa de personatge.", "photo": "Foto", "upload-photo": "Pujar foto", "change-photo": "Canviar foto", "remove-photo": "Treure foto", "uploading-photo": "Pujant...", "photo-error": "No s'ha pogut pujar aquesta foto.", "ability-scores": "Característiques", "proficiency-bonus": "Bonificador de competència",
"combat": "Combat", "armor-class": "Classe d'armadura", "speed": "Velocitat", "initiative": "Iniciativa", "combat": "Combat", "armor-class": "Classe d'armadura", "speed": "Velocitat", "initiative": "Iniciativa",
"hit-points": "Punts de cop", "max-hit-points": "Punts de cop màxims", "hit-dice": "Daus de cop", "max-hit-dice": "Daus de cop màxims", "proficiencies": "Competències", "hit-points": "Punts de cop", "max-hit-points": "Punts de cop màxims", "hit-dice": "Daus de cop", "max-hit-dice": "Daus de cop màxims", "proficiencies": "Competències",
"proficiencies-placeholder": "Afegeix salvacions, habilitats, armadures, armes, eines i idiomes...", "empty-proficiencies": "No hi ha competències afegides.", "proficiencies-placeholder": "Afegeix armadures, armes i qualsevol altra competència del personatge...", "empty-proficiencies": "No hi ha competències afegides.",
"saving-throws": "Tirades de salvació", "skills": "Habilitats",
"abilities": { "str": "Força", "dex": "Destresa", "con": "Constitució", "int": "Intel·ligència", "wis": "Saviesa", "cha": "Carisma" },
"skill-names": {
"acrobatics": "Acrobàcies", "animalHandling": "Tracte amb els animals", "arcana": "Arcan", "athletics": "Atletisme",
"deception": "Engany", "history": "Història", "insight": "Penetració", "intimidation": "Intimidació",
"investigation": "Investigació", "medicine": "Medicina", "nature": "Naturalesa", "perception": "Percepció",
"performance": "Actuació", "persuasion": "Persuasió", "religion": "Religió", "sleightOfHand": "Jocs de mans",
"stealth": "Furtivitat", "survival": "Supervivència"
},
"tools": "Eines", "tools-placeholder": "Escriu les eines, una per línia...", "empty-tools": "Cap competència amb eines.",
"languages": "Idiomes", "languages-placeholder": "Escriu els idiomes, un per línia...", "empty-languages": "Cap idioma.",
"traits": "Trets", "traits-placeholder": "Afegeix trets, capacitats i altres detalls...", "empty-traits": "No hi ha trets afegits.", "traits": "Trets", "traits-placeholder": "Afegeix trets, capacitats i altres detalls...", "empty-traits": "No hi ha trets afegits.",
"spells": "Conjurs", "spells-placeholder": "Escriu els conjurs, un per línia...", "empty-spells": "No hi ha conjurs afegits.", "spells": "Conjurs", "spells-placeholder": "Escriu els conjurs, un per línia...", "empty-spells": "No hi ha conjurs afegits.",
"inventory": "Inventari", "add-item": "Afegeix un objecte", "carried-weight": "Pes transportat", "item-name": "Objecte", "inventory": "Inventari", "add-item": "Afegeix un objecte", "carried-weight": "Pes transportat", "item-name": "Objecte",
"quantity": "Quant.", "weight-each": "Unitat (lb)", "total-weight": "Total (lb)", "actions": "Accions", "empty-inventory": "L'inventari és buit." "quantity": "Quant.", "weight-each": "Unitat (lb)", "total-weight": "Total (lb)", "actions": "Accions", "empty-inventory": "L'inventari és buit.",
"currency": "Monedes", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icona"
} }
} }

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" },
@@ -126,10 +133,22 @@
"uploading-photo": "Uploading...", "photo-error": "Unable to upload this photo.", "ability-scores": "Ability Scores", "proficiency-bonus": "Proficiency Bonus", "uploading-photo": "Uploading...", "photo-error": "Unable to upload this photo.", "ability-scores": "Ability Scores", "proficiency-bonus": "Proficiency Bonus",
"combat": "Combat", "armor-class": "Armor Class", "speed": "Speed", "initiative": "Initiative", "combat": "Combat", "armor-class": "Armor Class", "speed": "Speed", "initiative": "Initiative",
"hit-points": "Hit Points", "max-hit-points": "Maximum hit points", "hit-dice": "Hit Dice", "max-hit-dice": "Maximum hit dice", "proficiencies": "Proficiencies", "hit-points": "Hit Points", "max-hit-points": "Maximum hit points", "hit-dice": "Hit Dice", "max-hit-dice": "Maximum hit dice", "proficiencies": "Proficiencies",
"proficiencies-placeholder": "Add saving throws, skills, armor, weapons, tools, and languages...", "empty-proficiencies": "No proficiencies added.", "proficiencies-placeholder": "Add armor, weapons, and anything else the character is proficient with...", "empty-proficiencies": "No proficiencies added.",
"saving-throws": "Saving Throws", "skills": "Skills",
"abilities": { "str": "Strength", "dex": "Dexterity", "con": "Constitution", "int": "Intelligence", "wis": "Wisdom", "cha": "Charisma" },
"skill-names": {
"acrobatics": "Acrobatics", "animalHandling": "Animal Handling", "arcana": "Arcana", "athletics": "Athletics",
"deception": "Deception", "history": "History", "insight": "Insight", "intimidation": "Intimidation",
"investigation": "Investigation", "medicine": "Medicine", "nature": "Nature", "perception": "Perception",
"performance": "Performance", "persuasion": "Persuasion", "religion": "Religion", "sleightOfHand": "Sleight of Hand",
"stealth": "Stealth", "survival": "Survival"
},
"tools": "Tools", "tools-placeholder": "List tools, one per line...", "empty-tools": "No tool proficiencies.",
"languages": "Languages", "languages-placeholder": "List languages, one per line...", "empty-languages": "No languages.",
"traits": "Traits", "traits-placeholder": "Add features, traits, and other character details...", "empty-traits": "No traits added.", "traits": "Traits", "traits-placeholder": "Add features, traits, and other character details...", "empty-traits": "No traits added.",
"spells": "Spells", "spells-placeholder": "List spells, one per line...", "empty-spells": "No spells added.", "spells": "Spells", "spells-placeholder": "List spells, one per line...", "empty-spells": "No spells added.",
"inventory": "Inventory", "add-item": "Add item", "carried-weight": "Carried weight", "item-name": "Item", "inventory": "Inventory", "add-item": "Add item", "carried-weight": "Carried weight", "item-name": "Item",
"quantity": "Qty", "weight-each": "Each (lb)", "total-weight": "Total (lb)", "actions": "Actions", "empty-inventory": "Inventory is empty." "quantity": "Qty", "weight-each": "Each (lb)", "total-weight": "Total (lb)", "actions": "Actions", "empty-inventory": "Inventory is empty.",
"currency": "Currency", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icon"
} }
} }

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" },
@@ -120,10 +127,22 @@
"saving": "Guardando...", "save": "Guardar hoja", "save-error": "No se pudo guardar esta hoja de personaje.", "photo": "Foto", "upload-photo": "Subir foto", "change-photo": "Cambiar foto", "remove-photo": "Quitar foto", "uploading-photo": "Subiendo...", "photo-error": "No se pudo subir esta foto.", "ability-scores": "Características", "proficiency-bonus": "Bonificador por competencia", "saving": "Guardando...", "save": "Guardar hoja", "save-error": "No se pudo guardar esta hoja de personaje.", "photo": "Foto", "upload-photo": "Subir foto", "change-photo": "Cambiar foto", "remove-photo": "Quitar foto", "uploading-photo": "Subiendo...", "photo-error": "No se pudo subir esta foto.", "ability-scores": "Características", "proficiency-bonus": "Bonificador por competencia",
"combat": "Combate", "armor-class": "Clase de armadura", "speed": "Velocidad", "initiative": "Iniciativa", "combat": "Combate", "armor-class": "Clase de armadura", "speed": "Velocidad", "initiative": "Iniciativa",
"hit-points": "Puntos de golpe", "max-hit-points": "Puntos de golpe máximos", "hit-dice": "Dados de golpe", "max-hit-dice": "Dados de golpe máximos", "proficiencies": "Competencias", "hit-points": "Puntos de golpe", "max-hit-points": "Puntos de golpe máximos", "hit-dice": "Dados de golpe", "max-hit-dice": "Dados de golpe máximos", "proficiencies": "Competencias",
"proficiencies-placeholder": "Añade salvaciones, habilidades, armaduras, armas, herramientas e idiomas...", "empty-proficiencies": "No hay competencias añadidas.", "proficiencies-placeholder": "Añade armaduras, armas y cualquier otra competencia del personaje...", "empty-proficiencies": "No hay competencias añadidas.",
"saving-throws": "Tiradas de salvación", "skills": "Habilidades",
"abilities": { "str": "Fuerza", "dex": "Destreza", "con": "Constitución", "int": "Inteligencia", "wis": "Sabiduría", "cha": "Carisma" },
"skill-names": {
"acrobatics": "Acrobacias", "animalHandling": "Trato con animales", "arcana": "Arcano", "athletics": "Atletismo",
"deception": "Engaño", "history": "Historia", "insight": "Perspicacia", "intimidation": "Intimidación",
"investigation": "Investigación", "medicine": "Medicina", "nature": "Naturaleza", "perception": "Percepción",
"performance": "Interpretación", "persuasion": "Persuasión", "religion": "Religión", "sleightOfHand": "Manualidades",
"stealth": "Sigilo", "survival": "Supervivencia"
},
"tools": "Herramientas", "tools-placeholder": "Escribe las herramientas, una por línea...", "empty-tools": "Sin competencias con herramientas.",
"languages": "Idiomas", "languages-placeholder": "Escribe los idiomas, uno por línea...", "empty-languages": "Sin idiomas.",
"traits": "Rasgos", "traits-placeholder": "Añade rasgos, capacidades y otros detalles...", "empty-traits": "No hay rasgos añadidos.", "traits": "Rasgos", "traits-placeholder": "Añade rasgos, capacidades y otros detalles...", "empty-traits": "No hay rasgos añadidos.",
"spells": "Conjuros", "spells-placeholder": "Escribe los conjuros, uno por línea...", "empty-spells": "No hay conjuros añadidos.", "spells": "Conjuros", "spells-placeholder": "Escribe los conjuros, uno por línea...", "empty-spells": "No hay conjuros añadidos.",
"inventory": "Inventario", "add-item": "Añadir objeto", "carried-weight": "Peso transportado", "item-name": "Objeto", "inventory": "Inventario", "add-item": "Añadir objeto", "carried-weight": "Peso transportado", "item-name": "Objeto",
"quantity": "Cant.", "weight-each": "Unidad (lb)", "total-weight": "Total (lb)", "actions": "Acciones", "empty-inventory": "El inventario está vacío." "quantity": "Cant.", "weight-each": "Unidad (lb)", "total-weight": "Total (lb)", "actions": "Acciones", "empty-inventory": "El inventario está vacío.",
"currency": "Monedas", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icono"
} }
} }

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

@@ -0,0 +1,623 @@
// Tests for Syndria98/dragonroll#83, the things the character sheet did not hold:
// * the eighteen skills down the ability scores tab, each with a circle that stands lit
// when the character is proficient with it, and the six saving throws beside them,
// * proficiencies with tools and with languages,
// * the coins a character carries and the icon of each item it carries,
// * and traits that reach the campaign from the linked Foundry world.
//
// The window is a `.vue` file and the repository root installs no dependencies for it, so
// its template, styles and plain functions are read out of the source the way
// tests/character-sheet-tabs.test.js and tests/character-sheet-portrait-column.test.js
// read them. The Foundry mapper is plain CommonJS and is required for real; the actor
// route runs in a stubbed `require` against fake models, like tests/foundry-force-import.test.js.
// The Foundry module goes into a `node:vm` context with stubbed globals, like
// tests/foundry-sync-toggle.test.js, so what its actor snapshot carries is observable.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const MODULE_ID = "dragonroll-foundry";
const sheetSource = read("frontend", "app", "components", "windows", "CharacterSheetWindow.vue");
const script = /<script setup>([\s\S]*?)<\/script>/.exec(sheetSource)?.[1] ?? "";
const template = /<template>([\s\S]*)<\/template>/.exec(sheetSource)?.[1] ?? "";
const actorModelSource = read("backend", "src", "models", "Actor.js");
// `fromSource` hands back one top-level declaration as a value, like the other character
// sheet tests do it.
function fromSource(source, pattern, locals = {}) {
const declaration = pattern.exec(source)?.[0];
assert.ok(declaration, `expected ${pattern} in the source`);
const name = /(?:const|function)\s+(\w+)/.exec(declaration)[1];
return new Function(...Object.keys(locals), `${declaration}\n;return ${name};`)(...Object.values(locals));
}
const abilityStats = fromSource(script, /const abilityStats = \[[\s\S]*?\];/);
const skillList = fromSource(script, /const skillList = \[[\s\S]*?\];/);
const currencyUnits = fromSource(script, /const currencyUnits = \[[\s\S]*?\];/);
const proficiencyText = fromSource(script, /function proficiencyText\(value\) \{[\s\S]*?\n\}/);
const proficiencyList = fromSource(script, /function proficiencyList\(text\) \{[\s\S]*?\n\}/);
const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\s\S]*?\n\}/, {
abilityStats, skillList, currencyUnits, proficiencyText
});
const skillKeys = skillList.map(({ key }) => key);
// --- The sheet: skills and saving throws on the ability scores tab -----------------
test("the sheet knows the eighteen skills, each under the ability that manages it", () => {
assert.deepEqual(skillKeys, [
"acrobatics", "animalHandling", "arcana", "athletics", "deception", "history", "insight",
"intimidation", "investigation", "medicine", "nature", "perception", "performance",
"persuasion", "religion", "sleightOfHand", "stealth", "survival"
]);
assert.deepEqual(
skillList.map(({ ability }) => ability),
["dex", "wis", "int", "str", "cha", "int", "wis", "cha", "int", "wis", "int", "wis", "cha", "cha", "int", "dex", "dex", "wis"],
"each skill stands with the ability D&D counts for it"
);
});
test("every skill stands with a circle that toggles whether the character is proficient", () => {
const panel = /<section class="sheet-panel skills-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(panel, /campaigns\.character-sheet\.skills/, "the panel is named for the skills");
assert.match(panel, /v-for="skill in skillList"/);
assert.match(panel, /:aria-checked="form\.skills\[skill\.key\]"/, "the circle says what it holds");
assert.match(panel, /@click="toggleProficiency\('skills', skill\.key\)"/);
assert.match(panel, /class="proficiency-dot"/);
assert.match(panel, /\{ proficient: form\.skills\[skill\.key\] \}/, "the circle stands lit for a proficiency");
assert.match(panel, /campaigns\.character-sheet\.skill-names\.\$\{skill\.key\}/, "the skill is called by its name");
assert.match(panel, /\{\{ skillModifier\(skill\) \}\}/, "and it shows the modifier the character rolls with it");
const toggle = /function toggleProficiency\(group, key\) \{[\s\S]*?\n\}/.exec(script)?.[0];
assert.match(toggle, /form\.value\[group\]\[key\] = !form\.value\[group\]\[key\]/, "the circle flips the toggle");
// The toggles belong to an edit in progress, like every other field of the sheet.
assert.match(panel, /:disabled="!editing"/);
});
test("the six saving throws ride with the ability scores", () => {
const abilities = /<section class="sheet-panel abilities-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(abilities, /campaigns\.character-sheet\.saving-throws/);
assert.match(abilities, /v-for="stat in abilityStats"/, "one save per ability score");
assert.match(abilities, /:aria-checked="form\.savingThrows\[stat\.key\]"/);
assert.match(abilities, /@click="toggleProficiency\('savingThrows', stat\.key\)"/);
assert.match(abilities, /\{\{ savingThrowModifier\(stat\) \}\}/);
// The ability scores themselves are untouched, and the saves stand under them.
assert.match(abilities, /v-model\.number="form\.abilityScores\[stat\.key\]"/);
assert.ok(
abilities.indexOf("ability-grid") < abilities.indexOf("saving-throw-grid"),
"the saving throws follow the scores they come from"
);
});
test("a skill's form entry starts off, and the world's toggles carry over", () => {
const fresh = normalizeActor({});
assert.deepEqual(fresh.skills.acrobatics, false);
assert.deepEqual(fresh.savingThrows.str, false);
assert.deepEqual(Object.keys(fresh.skills).length, 18, "every skill stands in the form, toggled or not");
assert.deepEqual(Object.keys(fresh.savingThrows).sort(), ["cha", "con", "dex", "int", "str", "wis"]);
const trained = normalizeActor({ skills: { stealth: true }, savingThrows: { con: true } });
assert.equal(trained.skills.stealth, true);
assert.equal(trained.savingThrows.con, true);
});
// --- Tools and languages ----------------------------------------------------------
test("tools and languages have a list of their own under the proficiencies", () => {
const panel = /<section class="sheet-panel proficiencies-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
for (const [key, field] of [["tools", "form.tools"], ["languages", "form.languages"]]) {
assert.match(panel, new RegExp(`campaigns\\.character-sheet\\.${key}`), `the ${key} are named`);
assert.match(panel, new RegExp(`v-model="${field}"`), `the ${key} are edited as text`);
assert.match(panel, new RegExp(`\\{\\{ ${field} \\|\\| \\$t\\('campaigns\\.character-sheet\\.empty-${key}'\\) \\}\\}`));
}
// The free text keeps what has no list of its own, so it no longer asks for these.
const placeholder = /"proficiencies-placeholder": "([^"]+)"/.exec(read("frontend", "i18n", "locales", "en", "campaigns.json"))[1];
assert.doesNotMatch(placeholder, /skills|saving throws|tools|languages/i, "the text field does not ask for what has its own list");
});
test("the tools and languages lists travel as a list and edit as one name per line", () => {
assert.deepEqual(normalizeActor({ tools: ["Thieves tools", "Dice set"] }).tools, "Thieves tools\nDice set");
assert.deepEqual(normalizeActor({ languages: [] }).languages, "");
assert.deepEqual(
normalizeActor({ tools: [" Thieves tools ", "Thieves tools", "", "Dice set"] }).tools,
"Thieves tools\nDice set",
"blanks, spaces and repeats are not kept"
);
assert.deepEqual(proficiencyList("Thieves tools\nDice set"), ["Thieves tools", "Dice set"]);
assert.deepEqual(proficiencyList("Common, Elvish, Common"), ["Common", "Elvish"], "a comma separates too");
assert.deepEqual(proficiencyList(""), []);
assert.deepEqual(proficiencyList(proficiencyText(["Cartographer's supplies"])), ["Cartographer's supplies"]);
});
// --- Currency and item icons on the inventory tab ---------------------------------
test("the inventory shows the coins the character carries", () => {
assert.deepEqual(currencyUnits, ["pp", "gp", "ep", "sp", "cp"]);
const panel = /<main v-show="activeTab === 'inventory'"[\s\S]*?<\/main>/.exec(template)?.[0] ?? "";
assert.match(panel, /campaigns\.character-sheet\.currency/);
assert.match(panel, /v-for="unit in currencyUnits"/);
assert.match(panel, /v-model\.number="form\.currency\[unit\]"/, "each coin can be counted in");
assert.match(panel, /\{\{ form\.currency\[unit\] \}\}/, "and reads back outside of editing");
assert.deepEqual(normalizeActor({}).currency, { pp: 0, gp: 0, ep: 0, sp: 0, cp: 0 });
assert.deepEqual(normalizeActor({ currency: { gp: 12, cp: "40" } }).currency, { pp: 0, gp: 12, ep: 0, sp: 0, cp: 40 });
});
test("every inventory row opens with the item's icon", () => {
const panel = /<main v-show="activeTab === 'inventory'"[\s\S]*?<\/main>/.exec(template)?.[0] ?? "";
const iconCell = /<td class="item-icon-cell">([\s\S]*?)<\/td>/.exec(panel)?.[1] ?? "";
assert.match(iconCell, /v-if="item\.icon"/);
assert.match(iconCell, /:src="resolveImage\(item\.icon\)"/, "a world's own icon and an upload both resolve");
assert.match(iconCell, /item-icon-blank/, "and a row without one leaves the place marked");
// The icon comes first, and the name it stands in front of keeps reading left.
const firstCells = /<tr v-for="\(item, index\) in form\.inventory" :key="index">([\s\S]*?)<\/td>\s*([\s\S]*?)<\/td>/.exec(panel);
assert.match(firstCells[1], /item-icon-cell/);
assert.match(firstCells[2], /item-name-cell/);
const aligns = /\.inventory-table th:not\(:first-child\):not\(\.item-name-cell\)/.exec(sheetSource)?.[0];
assert.ok(aligns, "the name column is let go of the centred columns");
assert.equal(normalizeActor({ inventory: [{ name: "Torch" }] }).inventory[0].icon, "");
assert.equal(
normalizeActor({ inventory: [{ name: "Torch", icon: "http://vtt.test/icons/torch.svg" }] }).inventory[0].icon,
"http://vtt.test/icons/torch.svg"
);
});
// --- The model and the route ------------------------------------------------------
test("the Actor model holds the skills, the saves, the tools, the languages and the coins", () => {
for (const key of skillKeys) {
assert.match(actorModelSource, new RegExp(`${key}: \\{ type: Boolean, default: false \\}`), `${key} is a toggle`);
}
for (const key of ["str", "dex", "con", "int", "wis", "cha"]) {
assert.ok(
new RegExp(`savingThrows: \\{[\\s\\S]*?${key}: \\{ type: Boolean, default: false \\}`).test(actorModelSource),
`the ${key} saving throw stands in the model`
);
}
assert.match(actorModelSource, /tools: \[\{ type: String, trim: true \}\]/);
assert.match(actorModelSource, /languages: \[\{ type: String, trim: true \}\]/);
for (const unit of currencyUnits) {
assert.ok(
new RegExp(`currency: \\{[\\s\\S]*?${unit}: \\{ type: Number, min: 0, default: 0 \\}`).test(actorModelSource),
`${unit} counts among the coins`
);
}
assert.match(actorModelSource, /icon: \{ type: String, default: '' \}/, "a carried item keeps its icon");
});
// The actor update route with every require stubbed, the way
// tests/foundry-force-import.test.js runs the import route.
function loadActorRoute(actor) {
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 === "../models/Campaign") {
return { findOne: () => ({ lean: () => Promise.resolve({ _id: "campaign-1" }) }) };
}
if (id === "../models/Actor") return { findById: async () => actor };
if (id === "../models/Folder") return { belongsToSection: async () => true };
if (id === "../models/Map") return { updateMany: async () => ({}) };
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "actor.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function update(body, user = { id: "user-1" }) {
const handlers = routes.get("POST /update");
assert.ok(handlers, "POST /update is not mounted");
let payload = null;
await handlers[handlers.length - 1]({ body, user }, { json: (sent) => { payload = sent; } });
return payload;
}
return { update };
}
test("the actor update writes the skills, the saves, the tools, the languages and the coins", async () => {
const actor = { _id: "actor-1", campaign: "campaign-1", save: async () => {} };
const route = loadActorRoute(actor);
const response = await route.update({
id: "actor-1",
skills: { acrobatics: true, stealth: false },
savingThrows: { con: true },
tools: [" Thieves tools ", "Thieves tools", "", "Dice set"],
languages: ["Elvish", "Undercommon"],
currency: { gp: 12, cp: 40 },
inventory: [{ name: "Torch", quantity: 2, weight: 0.5, icon: "icons/torch.svg" }],
});
assert.equal(response.status, "ok");
assert.deepEqual(actor.skills, { acrobatics: true, stealth: false });
assert.deepEqual(actor.savingThrows, { con: true });
assert.deepEqual(actor.tools, ["Thieves tools", "Dice set"], "blanks and repeats are written out of the lists");
assert.deepEqual(actor.languages, ["Elvish", "Undercommon"]);
assert.deepEqual(actor.currency, { gp: 12, cp: 40 });
assert.deepEqual(actor.inventory, [{ name: "Torch", quantity: 2, weight: 0.5, icon: "icons/torch.svg" }]);
});
test("an update that says nothing about them leaves the toggles and lists where they are", async () => {
const actor = {
_id: "actor-1",
campaign: "campaign-1",
skills: { acrobatics: true },
tools: ["Disguise kit"],
currency: { gp: 3 },
save: async () => {},
};
const route = loadActorRoute(actor);
const response = await route.update({ id: "actor-1", name: "Thalia" });
assert.equal(response.status, "ok");
assert.equal(actor.name, "Thalia");
assert.deepEqual(actor.skills, { acrobatics: true });
assert.deepEqual(actor.tools, ["Disguise kit"]);
assert.deepEqual(actor.currency, { gp: 3 });
});
// --- The Foundry world fills them in ---------------------------------------------
const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js"));
test("a world's skill and saving throw proficiencies arrive toggled", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: {
skills: { acr: { value: 1 }, stl: { value: 0 }, prc: { value: 2 }, arc: { value: ["exp"] }, his: { value: [] } },
savingThrows: { str: { value: 1 }, dex: { value: 0 }, con: { prof: { value: 2 } } },
},
});
assert.deepEqual(character.skills, {
acrobatics: true, stealth: false, arcana: true, history: false, perception: true,
});
assert.deepEqual(character.savingThrows, { str: true, dex: false, con: true });
});
test("an older world holding its saves under the abilities is read the same way", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { abilities: { str: { save: 0 }, dex: { save: 1 } }, saves: { con: { proficient: true } } },
});
assert.deepEqual(character.savingThrows, { str: false, dex: true, con: true });
});
test("a world that says nothing about skills or saves leaves what the campaign toggled", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: { abilities: { str: { value: 16 } } } });
assert.ok(!("skills" in character), "no skills to report is not the same as none proficient");
assert.ok(!("savingThrows" in character));
assert.ok(!("currency" in character));
assert.ok(!("tools" in character), "and neither are the tool and language lists");
assert.ok(!("languages" in character));
});
test("the tools and languages the module names come over as they are named", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { traits: { tool: { value: ["xyz12abc345def67"] }, languages: { value: ["aB3cD9eF1gH2iJ4k"] } } },
dragonroll: { tools: ["Thieves' tools", "Dice set"], languages: ["Elvish", "Deep Speech"] },
});
assert.deepEqual(character.tools, ["Thieves' tools", "Dice set"]);
assert.deepEqual(character.languages, ["Elvish", "Deep Speech"]);
});
test("without the module's names the proficiency keys are read off the actor", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: {
traits: {
tool: { value: ["thieves", "alchemist"], custom: "Dice set, Playing cards" },
languages: { value: ["common", "aB3cD9eF1gH2iJ4k"], custom: "Thieves' cant" },
},
},
});
assert.deepEqual(character.tools, ["thieves", "alchemist", "Dice set", "Playing cards"]);
assert.deepEqual(
character.languages,
["common", "Thieves' cant"],
"a language the sheet cannot name is dropped rather than shown as a document id"
);
const none = foundryActorToCharacter({ name: "Thalia", system: { traits: { tool: { value: [] } } } });
assert.deepEqual(none.tools, [], "a world with no tool proficiency says so");
assert.ok(!("languages" in none), "and says nothing at all about the ones it does not list");
});
test("the coins of the world are the coins of the campaign", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: { currency: { pp: 1, gp: 25, sp: -3 } } });
assert.deepEqual(character.currency, { pp: 1, gp: 25, ep: 0, sp: 0, cp: 0 }, "and never a debt");
});
test("a carried item brings its own icon", () => {
const character = foundryActorToCharacter({
name: "Thalia",
items: [
{ name: "Longsword", type: "weapon", img: "http://vtt.test/icons/sword.svg", system: { quantity: 1, weight: { value: 3 } } },
{ name: "Rope", type: "equipment", system: { quantity: 2 } },
],
});
assert.deepEqual(character.inventory, [
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" },
{ name: "Rope", quantity: 2, weight: 0, icon: "" },
]);
});
// --- The traits tab syncs --------------------------------------------------------
test("the world's own traits and features reach the campaign", () => {
const fromText = foundryActorToCharacter({ name: "Thalia", system: { details: { trait: "Spellcaster.<br>Light sleeper." } } });
assert.equal(fromText.traits, "Spellcaster.\nLight sleeper.");
const fromFeatures = foundryActorToCharacter({
name: "Thalia",
system: {},
items: [
{ name: "Darkvision", type: "feat", img: "http://vtt.test/icons/eye.svg", system: { type: { value: "race" }, description: { value: "<p>See in the dark.</p>" } } },
{ name: "Second Wind", type: "feat", system: { type: { value: "class" }, description: { value: "Regain hit points." } } },
{ name: "Alert", type: "feat", system: { type: { value: "feat" }, description: { value: "Never surprised." } } },
],
});
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", () => {
// The module carries whatever the campaign shows for the traits back to the world on
// its flag, and the actor's own traits lead from there: a world keeps its traits in
// step the same way it keeps its proficiencies in step, while a character the world
// says nothing about keeps what the campaign wrote for it.
const fromWorld = foundryActorToCharacter({
name: "Thalia",
system: { details: { trait: "The world's own traits" } },
flags: { [MODULE_ID]: { traits: "What the campaign typed" } },
});
assert.equal(fromWorld.traits, "The world's own traits");
const fromCampaign = foundryActorToCharacter({
name: "Thalia",
system: {},
flags: { [MODULE_ID]: { traits: "What the campaign typed" } },
});
assert.equal(fromCampaign.traits, "What the campaign typed");
});
test("an actor that holds no traits does not clear what the campaign has", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: {}, items: [], flags: {} });
assert.ok(!("traits" in character), "a live edit that knows nothing about traits leaves the tab as it is");
});
test("features stand like inventory rows and open their description", () => {
const panel = /<section class="sheet-panel traits-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(panel, /v-for="\(trait, index\) in form\.features"/, "one row per feature");
assert.match(panel, /resolveImage\(trait\.icon\)/, "the world's icon sits on the left");
assert.match(panel, /@click="openTrait\(trait\)"/, "clicking a row opens its description");
assert.match(read("frontend", "app", "services", "WindowDefinitions.js"), /trait_sheet: \{/);
assert.deepEqual(
normalizeActor({ features: [{ name: "Darkvision", description: "See in the dark.", icon: "eye.svg" }] }).features,
[{ name: "Darkvision", description: "See in the dark.", icon: "eye.svg" }]
);
assert.deepEqual(normalizeActor({}).features, []);
});
// A forced actor sync from the module's context menu replaces everything the campaign
// holds for that actor (Syndria98/dragonroll#96): the fields a live edit leaves out when
// the world says nothing are written empty instead of kept, and the campaign's own text
// on the actor's flag does not survive it.
test("a forced sync writes empty the fields a live edit would leave out", () => {
const actor = {
name: "Thalia",
system: {},
items: [],
flags: { [MODULE_ID]: { traits: "What the campaign typed", proficiencies: "Armour, tools" } },
};
const live = foundryActorToCharacter(actor);
assert.equal(live.traits, "What the campaign typed", "a live edit fills the traits tab from the actor's flag");
assert.equal(live.proficiencies, "Armour, tools", "and the free-text proficiencies from it too");
assert.ok(
!("tools" in live) && !("languages" in live) && !("skills" in live) && !("savingThrows" in live) && !("currency" in live),
"and says nothing about the toggles and lists the world has no data for"
);
const replaced = foundryActorToCharacter(actor, true);
assert.equal(replaced.traits, "", "a forced sync clears the traits the campaign typed");
assert.equal(replaced.proficiencies, "", "down to the free-text proficiencies");
assert.deepEqual(replaced.tools, []);
assert.deepEqual(replaced.languages, []);
assert.deepEqual(replaced.skills, {});
assert.deepEqual(replaced.savingThrows, {});
assert.deepEqual(replaced.currency, {});
});
// --- The module sends the names a sheet outside Foundry can read -----------------
function makeWorld({ actor, config = {}, worldItems = [] }) {
const state = { hooks: new Map(), requests: [], timers: new Map(), nextTimerId: 1 };
const documents = [actor];
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: 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) => { const id = state.nextTimerId++; state.timers.set(id, { fn }); return id; },
clearTimeout: (id) => state.timers.delete(id),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
state.requests.push({ href: String(url), body: options.body ? JSON.parse(options.body) : null });
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: documents, get: (id) => documents.find((document) => document.id === id) },
items: { contents: worldItems, get: (id) => worldItems.find((document) => document.id === id) },
folders: { contents: [], get: () => null },
settings: {
register(module, key, definition) {
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) { settingsStore[key] = value; },
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
// Only the pushes of an actor count here: the world start sends one, and what an
// actor changed sends the next.
state.actorPushes = () => state.requests
.filter((request) => request.href.includes("foundry/sync/snapshot"))
.map((request) => request.body.actors[0]);
return state;
}
function makeStubActor(id, name, system = {}, items = []) {
return {
id,
name,
type: "character",
documentName: "Actor",
img: "icons/svg/mystery-man.svg",
system,
flags: {},
items: { contents: items },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(data) { return data; },
toObject() { return { _id: this.id, name: this.name, type: this.type, img: this.img, flags: this.flags, system: this.system }; },
};
}
// A world document of its own — a language since the third release of the system —
// plain enough to serialize like any other item of the world.
function makeWorldItem(id, name) {
return {
id,
name,
type: "loot",
documentName: "Item",
parent: null,
folder: null,
flags: {},
system: {},
getFlag() { return undefined; },
toObject() { return { _id: this.id, name: this.name, type: this.type, flags: this.flags, system: this.system }; },
};
}
async function pushAfterEdit(actor, options) {
const world = makeWorld(options);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateActor", actor);
await world.runTimers();
return world.actorPushes().at(-1);
}
test("the actor snapshot names the world's tools and languages", async () => {
const actor = makeStubActor("actor-1", "Thalia", {
traits: {
tool: { value: ["thieves"], custom: "Dice set" },
languages: { value: ["common", "lang-1"] },
},
});
const sent = await pushAfterEdit(actor, {
config: {
DND5E: {
tools: { thieves: { label: "Thieves' tools" } },
languages: { common: { name: "Common" } },
},
},
worldItems: [makeWorldItem("lang-1", "Deep Speech")],
});
assert.equal(sent._id, "actor-1", "the actor the world edited is the one that was sent");
assert.deepEqual(sent.dragonroll.tools, ["Thieves' tools", "Dice set"]);
assert.deepEqual(sent.dragonroll.languages, ["Common", "Deep Speech"]);
});
test("an actor listing no tools or languages says nothing about them", async () => {
const actor = makeStubActor("actor-1", "Grunt", { details: { level: 1 } });
const sent = await pushAfterEdit(actor, { config: { DND5E: { tools: { thieves: { label: "Thieves' tools" } } } } });
assert.equal(sent.dragonroll, undefined, "no dragonroll block is what tells the campaign nothing was said");
});
// --- Every locale says it ------------------------------------------------------
test("every locale names the skills, the saving throws, the tools, the languages and the coins", () => {
for (const locale of ["en", "es", "ca"]) {
const sheet = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"))["character-sheet"];
for (const key of ["skills", "saving-throws", "tools", "languages", "currency", "item-icon"]) {
assert.ok(sheet[key], `${locale} is missing campaigns.character-sheet.${key}`);
}
for (const [group, keys] of [["abilities", ["str", "dex", "con", "int", "wis", "cha"]], ["skill-names", skillKeys], ["currency-units", currencyUnits]]) {
for (const key of keys) {
assert.ok(sheet[group]?.[key], `${locale} is missing campaigns.character-sheet.${group}.${key}`);
}
}
assert.deepEqual(Object.keys(sheet["skill-names"]).sort(), [...skillKeys].sort(), `${locale} names every skill the sheet lists`);
assert.notEqual(sheet["skill-names"].acrobatics, "acrobatics", `${locale} spells the skill out, not its key`);
}
});

View File

@@ -0,0 +1,111 @@
// Tests for Syndria98/dragonroll#91: the column that opens the character sheet — the portrait with
// the armor class, the speed, the bonuses and both pools under it — stays on screen whoever's tab is
// open, instead of being the ability scores tab's own content and disappearing when the sheet moves
// to the inventory, the traits or the spells.
//
// The window is a `.vue` file and the repository root installs no dependencies for the frontend, so
// the template and the styles are read out of the source the way tests/character-sheet-tabs.test.js
// and tests/character-sheet-portrait-column.test.js read 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 read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const sheetSource = read("frontend", "app", "components", "windows", "CharacterSheetWindow.vue");
const template = /<template>([\s\S]*)<\/template>/.exec(sheetSource)?.[1] ?? "";
const TAB_KEYS = ["abilities", "inventory", "traits", "spells"];
const COLUMN = '<div class="character-column">';
function tabBody(key) {
const block = new RegExp(`<main v-show="activeTab === '${key}'"[\\s\\S]*?</main>`).exec(template)?.[0];
assert.ok(block, `expected a body for the ${key} tab`);
return block;
}
// The column, taken whole: it stands ahead of the tab bodies, which are its siblings.
function characterColumn() {
const start = template.indexOf(COLUMN);
const end = template.indexOf('<main v-show="activeTab');
assert.ok(start !== -1 && end > start, "expected the character column ahead of the tab bodies");
return template.slice(start, end);
}
// The classes wrapping a tag, worked out by walking the blocks of the template in order the way a
// browser nests them, so a tab cannot hide the column by wrapping it.
function ancestorsOf(needle) {
const at = template.indexOf(needle);
assert.ok(at !== -1, `expected ${needle} in the template`);
const stack = [];
for (const match of template.matchAll(/<(\/?)(div|main|section|header|nav)\b([^>]*)>/g)) {
if (match.index > at) break;
const [, closed, , attrs] = match;
if (closed) stack.pop();
else if (!attrs.trimEnd().endsWith("/")) {
const classes = /\bclass="([^"]*)"/.exec(attrs);
stack.push(classes ? classes[1].trim().split(/\s+/) : []);
}
}
return stack.slice(0, -1).map((classes) => classes.join(" "));
}
test("the character column belongs to no tab", () => {
const column = characterColumn();
assert.ok(column.includes('class="sheet-portrait"'), "the portrait is part of the column");
assert.ok(column.includes('class="sheet-panel vitals-panel"'), "and so is the panel of readouts and bars");
// Nothing toggles the column: no tab decides whether it shows.
assert.doesNotMatch(column, /v-show=/, "the column never hides behind a tab");
for (const key of TAB_KEYS) {
const body = tabBody(key);
assert.doesNotMatch(body, /class="character-column"/, `the ${key} tab does not own the column`);
assert.doesNotMatch(body, /sheet-portrait|vitals-panel/, `the ${key} tab does not hold the column's contents`);
}
});
test("the column and the tab that is open stand beside each other", () => {
const columnWrappers = ancestorsOf(COLUMN);
assert.equal(columnWrappers.at(-1), "sheet-layout", "the column stands in the sheet's own layout");
for (const key of TAB_KEYS) {
assert.deepEqual(
ancestorsOf(`<main v-show="activeTab === '${key}'"`),
columnWrappers,
`the ${key} tab is a sibling of the column, so it is never wrapped around it`
);
}
const layout = /\.sheet-layout\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(layout, /display:\s*grid/, "the layout puts the column and the open tab side by side");
assert.match(
layout,
/grid-template-columns:\s*minmax\(200px,\s*34%\)\s+minmax\(0,\s*1fr\)/,
"the character keeps its own column and the tab has all the room left"
);
const columnRule = /\.character-column\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(columnRule, /grid-column:\s*1/, "the character stands in the first column");
const bodyRule = /\.sheet-tab-body\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(bodyRule, /grid-column:\s*2/, "the open tab takes the space beside it");
assert.match(bodyRule, /grid-row:\s*1/, "and on the same row, so switching a tab leaves the column where it was");
});
test("a narrow window stacks the column over the tab instead of hiding it", () => {
const narrow = /@media \(max-width: 760px\)\s*\{([\s\S]*?)\n\}/.exec(sheetSource)?.[1] ?? "";
assert.match(narrow, /\.sheet-layout\s*\{[^}]*grid-template-columns:\s*1fr/, "the two columns become one");
assert.match(
narrow,
/\.character-column,\s*\.sheet-tab-body\s*\{[^}]*grid-column:\s*1 \/ -1;[^}]*grid-row:\s*auto/,
"the column goes over the tab, it does not go away with it"
);
});
test("what stays on screen is what the sheet is read for", () => {
const column = characterColumn();
for (const key of ["armor-class", "speed", "proficiency-bonus", "initiative", "hit-points", "hit-dice"]) {
assert.ok(column.includes(`campaigns.character-sheet.${key}`), `the ${key} stays visible from any tab`);
}
});

View File

@@ -34,11 +34,16 @@ function fromSource(source, pattern, locals = {}) {
} }
const abilityStats = fromSource(script, /const abilityStats = \[[\s\S]*?\];/); const abilityStats = fromSource(script, /const abilityStats = \[[\s\S]*?\];/);
const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\s\S]*?\n\}/, { abilityStats }); // #83 put the skills, the saving throws, the tools, the languages and the coins into the
// sheet form, so reading that form out of the source reads their names along with it.
const skillList = fromSource(script, /const skillList = \[[\s\S]*?\];/);
const currencyUnits = fromSource(script, /const currencyUnits = \[[\s\S]*?\];/);
const proficiencyText = fromSource(script, /function proficiencyText\(value\) \{[\s\S]*?\n\}/);
const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\s\S]*?\n\}/, { abilityStats, skillList, currencyUnits, proficiencyText });
const barPercent = fromSource(script, /function barPercent\(current, max\) \{[\s\S]*?\n\}/); const barPercent = fromSource(script, /function barPercent\(current, max\) \{[\s\S]*?\n\}/);
const barPool = fromSource(actorRouteSource, /function barPool\(existing, value\) \{[\s\S]*?\n\}/); const barPool = fromSource(actorRouteSource, /function barPool\(existing, value\) \{[\s\S]*?\n\}/);
// The column that opens the abilities tab: the portrait with everything under it. // The column that stands beside every tab: the portrait with everything under it.
function portraitColumn() { function portraitColumn() {
const start = template.indexOf('<div class="character-column">'); const start = template.indexOf('<div class="character-column">');
const end = template.indexOf('<section class="sheet-panel abilities-panel">'); const end = template.indexOf('<section class="sheet-panel abilities-panel">');
@@ -117,10 +122,14 @@ test("the initiative bonus is the modifier of dexterity", () => {
/const initiativeBonus = computed\(\(\) => abilityModifier\(form\.value\.abilityScores\.dex\)\)/, /const initiativeBonus = computed\(\(\) => abilityModifier\(form\.value\.abilityScores\.dex\)\)/,
"D&D counts initiative as the dexterity modifier while the character carries no extra bonus" "D&D counts initiative as the dexterity modifier while the character carries no extra bonus"
); );
const abilityModifier = fromSource(script, /function abilityModifier\(score\) \{[\s\S]*?\n\}/); // #83 gave the helper an optional proficiency bonus, for the skills and the saving
// throws the character is proficient with; the bare modifier is unchanged.
const abilityModifier = fromSource(script, /function abilityModifier\(score[^{]*\) \{[\s\S]*?\n\}/);
assert.equal(abilityModifier(16), "+3"); assert.equal(abilityModifier(16), "+3");
assert.equal(abilityModifier(10), "+0", "the sheet writes a flat modifier with its sign, as the ability cards do"); assert.equal(abilityModifier(10), "+0", "the sheet writes a flat modifier with its sign, as the ability cards do");
assert.equal(abilityModifier(9), "-1"); assert.equal(abilityModifier(9), "-1");
assert.equal(abilityModifier(16, 3), "+6", "a proficient skill adds the proficiency bonus to its modifier");
assert.equal(abilityModifier(8, 2), "+1", "and one below 10 counts its own negative modifier first");
}); });
test("an actor carries its pools, and one without them starts on its level", () => { test("an actor carries its pools, and one without them starts on its level", () => {

View File

@@ -53,7 +53,6 @@ function tabBody(key) {
test("every tab shows only its own content and hides the others", () => { test("every tab shows only its own content and hides the others", () => {
const abilities = tabBody("abilities"); const abilities = tabBody("abilities");
assert.match(abilities, /class="sheet-portrait"/, "the portrait stays with ability scores");
assert.match(abilities, /class="sheet-panel abilities-panel"/); assert.match(abilities, /class="sheet-panel abilities-panel"/);
assert.match(abilities, /class="sheet-panel proficiencies-panel"/, "the proficiencies ride with the ability scores"); assert.match(abilities, /class="sheet-panel proficiencies-panel"/, "the proficiencies ride with the ability scores");
for (const other of ["inventory-panel", "traits-panel", "spells-panel"]) { for (const other of ["inventory-panel", "traits-panel", "spells-panel"]) {
@@ -63,7 +62,12 @@ test("every tab shows only its own content and hides the others", () => {
for (const [key, panel] of [["inventory", "inventory-panel"], ["traits", "traits-panel"], ["spells", "spells-panel"]]) { for (const [key, panel] of [["inventory", "inventory-panel"], ["traits", "traits-panel"], ["spells", "spells-panel"]]) {
const body = tabBody(key); const body = tabBody(key);
assert.ok(body.includes(panel), `the ${key} tab shows the ${panel}`); assert.ok(body.includes(panel), `the ${key} tab shows the ${panel}`);
assert.doesNotMatch(body, /class="sheet-portrait"/); }
// #91 took the character column out of the tabs: it stands beside every one of them, so no tab
// body holds the portrait (see tests/character-sheet-persistent-column.test.js).
for (const key of ["abilities", "inventory", "traits", "spells"]) {
assert.doesNotMatch(tabBody(key), /class="sheet-portrait"/, `the portrait is not the ${key} tab's to hide`);
} }
// the panels are toggled, not unmounted, so editing on one tab and flipping away keeps the draft // the panels are toggled, not unmounted, so editing on one tab and flipping away keeps the draft

View File

@@ -0,0 +1,444 @@
// Tests for Syndria98/dragonroll#89: on the character sheet traits and items were all
// displayed together and the icons did not load. The world's mapper put every embedded
// document that was not a class, subclass, background or spell into the character's
// inventory — so its traits (feat items) and its species (the race item) stood in the
// inventory list beside the gear, while the sheet already shows both in fields of their
// own. And a world image that arrives as a Foundry path — the bridge's snapshot and older
// modules send those, where the module sends absolute URLs — was read against Dragonroll's
// uploads folder, where nothing of that name is, so nothing loaded.
//
// The mapper is plain CommonJS and is required for real. The writers run in a stubbed
// `require` against fake models, like tests/foundry-force-import.test.js runs them. And
// since the campaign's inventory no longer claims trait and species documents, the module
// must stop deleting ones earlier syncs marked as its own: the Foundry module goes into a
// `node:vm` context holding stubbed Foundry globals with fake timers, like
// tests/foundry-actor-details.test.js, so what writing a character leaves behind is observable.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
const MODULE_ID = "dragonroll-foundry";
// --- What the world's mapper keeps where -------------------------------------------------
const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js"));
test("traits and species stand in their own fields, not among the carried items", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { details: {} },
items: [
{ name: "Longsword", type: "weapon", img: "http://vtt.test/icons/sword.svg", system: { quantity: 1, weight: { value: 3 } } },
{ name: "Rope", type: "equipment", system: { quantity: 2 } },
{ name: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } },
{ name: "Human", type: "race" },
{ name: "Spellbook", type: "spellbook" },
{ name: "Magic Missile", type: "spell" },
{ name: "Fighter", type: "class" },
{ name: "Oracle", type: "subclass" },
{ name: "Soldier", type: "background" },
],
});
assert.deepEqual(character.inventory.map((item) => item.name), ["Longsword", "Rope"],
"the inventory holds what the character carries, and nothing else");
assert.deepEqual(character.inventory[0],
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" });
assert.deepEqual(character.features,
[{ name: "Darkvision", description: "See in the dark.", icon: "" }],
"the feat stands as a feature row, where the sheet shows it");
assert.equal(character.spells, "Magic Missile", "and the spell where its tab shows it");
});
test("gear of a type the mapper has never seen is still carried", () => {
const character = foundryActorToCharacter({
name: "Thalia",
items: [{ name: "Strange Relic", type: "loot", system: { quantity: 1 } }],
});
assert.deepEqual(character.inventory.map((item) => item.name), ["Strange Relic"],
"only the listed non-gear types are let out of the inventory");
});
// --- The writers read a world's paths off the world's address ----------------------------
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
limit: (count) => mongooseQuery(value.slice(0, count)),
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Enough of the query language the writers use: equality and $or.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
if (key === "$or") return expected.some((part) => matches(document, part));
const value = document?.[key];
if (expected && typeof expected === "object" && !Array.isArray(expected)) {
return Object.entries(expected).every(([operator, wanted]) => {
if (operator === "$exists") return (value !== undefined && value !== null) === wanted;
throw new Error(`filter operator "${key}.${operator}" is not stubbed`);
});
}
return String(value ?? "") === String(expected ?? "");
});
}
function fakeModel(table, seed = [], campaignId) {
const rows = [];
let counter = 0;
function Document(data = {}) {
counter += 1;
this._id = `${table}-${counter}`;
this.isNew = true;
this.foundryNames = [];
Object.assign(this, data);
}
Document.prototype.save = async function save() {
if (this.isNew) rows.push(this);
this.isNew = false;
return this;
};
Object.defineProperty(Document.prototype, "id", { get() { return this._id; } });
for (const data of seed) {
const row = new Document({ campaign: campaignId, ...data });
row.isNew = false;
rows.push(row);
}
const model = function Model(data) { return new Document(data); };
model.rows = rows;
model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null;
model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter)));
return model;
}
// The sync writers against fake models. `settings` is what the campaign keeps — the world
// address the icons are loaded from stands in it, as it does in the real one.
function loadFoundryWriters({ seed = {}, settings } = {}) {
const campaign = { _id: "campaign-1", id: "campaign-1", foundryWorldId: "world-1", ...(settings ? { settings } : {}) };
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => ({ get: () => {}, post: () => {} }) };
if (id.startsWith("node:")) return require(id);
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
return { campaign, models, writers: moduleStub.exports };
}
test("a world image that arrives as a path is stored as the address the sheet can load", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000/" } } });
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1",
name: "Thalia",
type: "character",
img: "icons/actors/thalia.svg",
items: [
{ name: "Torch", type: "loot", img: "icons/tools/torch torch.svg", system: { quantity: 2 } },
{ name: "Darkvision", type: "feat", img: "icons/svg/eye.svg" },
],
});
const actor = sync.models["../models/Actor"].rows[0];
assert.equal(actor.image, "http://vtt.test:30000/icons/actors/thalia.svg", "the portrait is read off the world's address");
assert.deepEqual(actor.inventory.map((item) => item.name), ["Torch"], "the feat is not carried into the inventory");
assert.equal(actor.inventory[0].icon, "http://vtt.test:30000/icons/tools/torch%20torch.svg", "and the gear's icon is");
});
test("the absolute addresses the module sends travel as they are", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1",
name: "Thalia",
img: "http://elsewhere.test/portraits/thalia.png",
items: [{ name: "Torch", type: "loot", img: "data:image/png;base64,TgA=" }],
});
const actor = sync.models["../models/Actor"].rows[0];
assert.equal(actor.image, "http://elsewhere.test/portraits/thalia.png");
assert.equal(actor.inventory[0].icon, "data:image/png;base64,TgA=");
});
test("a campaign with no world address keeps the path as it came", async () => {
const sync = loadFoundryWriters();
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1", name: "Thalia", img: "icons/actors/thalia.svg",
});
assert.equal(sync.models["../models/Actor"].rows[0].image, "icons/actors/thalia.svg",
"with no world to read it against, nothing is invented for it");
});
test("a world item's icon is read off the world's address the same way", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.writers.saveFoundryItem(sync.campaign, {
_id: "item-1", name: "Longsword", type: "weapon", img: "icons/equipment/sword.svg",
});
const item = sync.models["../models/Item"].rows[0];
assert.equal(item.image, "http://vtt.test:30000/icons/equipment/sword.svg");
assert.equal(item.foundryImage, "http://vtt.test:30000/icons/equipment/sword.svg",
"the icon the item window offers back is the loadable one too");
});
// --- The module leaves the world's own documents alone ------------------------------------
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);
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;
}
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 });
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;
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]);
state.actorPushes = () => state.requests
.filter((request) => request.href.includes("foundry/sync/snapshot"))
.map((request) => request.body.actors[0]);
return state;
}
test("the snapshot marks the carried gear and no longer the world's own documents", async () => {
const actor = makeStubActor("Grimnir", {
system: { details: {} },
items: [
{ name: "Longsword", type: "weapon" },
{ name: "Darkvision", type: "feat" },
{ name: "Giant", type: "race" },
],
});
await makeWorld({ actors: [actor], remoteActors: [] }).start();
const [sword, feat, race] = actor.items.contents;
assert.equal(sword.getFlag(MODULE_ID, "syncedItem"), true, "the gear the campaign carries is marked as its own");
assert.equal(feat.getFlag(MODULE_ID, "syncedItem"), undefined, "a trait is not");
assert.equal(race.getFlag(MODULE_ID, "syncedItem"), undefined, "neither is a species");
});
test("an actor snapshot still sends the feats its traits are made of", async () => {
// Leaving feats out of the inventory must not leave them out of the snapshot: they are
// what the campaign's traits tab reads.
const actor = makeStubActor("Thalia", {
system: { details: {} },
items: [{ name: "Darkvision", type: "feat", system: { featType: "trs" } }],
});
const world = await makeWorld({ actors: [actor], remoteActors: [] }).start();
const sent = world.actorPushes().at(-1);
assert.deepEqual(sent.items.map((item) => [item.type, item.name]), [["feat", "Darkvision"]],
"the feat still travels with its actor, as the traits text is read off it");
});

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
@@ -326,3 +328,237 @@ test("the main menu points at the documentation", () => {
assert.ok(strings.documentation, `${locale} has no label for the documentation link`); assert.ok(strings.documentation, `${locale} has no label for the documentation link`);
} }
}); });
// Inside a campaign the documentation is reached from the top bar, on the left of the campaign
// settings button (Syndria98/dragonroll#90), and it opens as a window of its own in front of the
// 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 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.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(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 button has to
// come first in it.
const docsAt = right.indexOf("OpenDocumentation");
const settingsAt = right.indexOf("OpenCampaignSettings");
assert.ok(
docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt,
"the documentation button sits on the left of the settings button"
);
// The open notes of the campaign live only in memory, so nothing the top bar does may leave
// the app: a window comes to the front, an address would take the campaign away with it.
assert.doesNotMatch(topBar, /href="\/docs"/, "the top bar does not send the campaign to /docs");
assert.doesNotMatch(topBar, /target="_blank"/, "…nor opens a tab out of it");
});
// The window the button opens (Syndria98/dragonroll#95): registered like every other window, and
// reading its pages without ever leaving the window it is drawn in.
test("the documentation is registered as a window", () => {
const definitions = readRepoFile("frontend", "app", "services", "WindowDefinitions.js");
const definition = /\n\s*documentation:\s*\{([\s\S]*?)\n\s{2}\}/.exec(definitions);
assert.ok(definition, "the documentation is not registered as a window");
assert.match(definition[1], /title:\s*'windows\.documentation'/, "its title is an i18n key");
assert.match(definition[1], /movable:\s*true/);
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`);
}
}
});
// --- How the documentation is laid out (Syndria98/dragonroll#85) ---
// The `<style>` of DocsView.vue read as `{ selector, media, declarations }` rules: the block is
// flat — every rule is a top level selector and the only nesting is the media queries — so pairing
// braces is enough, and the test does not need a stylesheet parser the repository root lacks.
function DocsStyleRules() {
const source = readRepoFile("frontend", "app", "components", "views", "DocsView.vue");
const css = source
.slice(source.indexOf(">", source.indexOf("<style")) + 1, source.indexOf("</style>"))
.replace(/\/\*[\s\S]*?\*\//g, "");
const rules = [];
function scan(text, media) {
let index = 0;
for (;;) {
const brace = text.indexOf("{", index);
if (brace === -1) return rules;
const selector = text.slice(index, brace).trim();
let depth = 1;
let cursor = brace + 1;
while (cursor < text.length && depth > 0) {
if (text[cursor] === "{") depth += 1;
else if (text[cursor] === "}") depth -= 1;
cursor += 1;
}
const body = text.slice(brace + 1, cursor - 1);
if (selector.startsWith("@")) scan(body, selector);
else rules.push({ selector, media, declarations: body });
index = cursor;
}
}
return scan(css, null);
}
const styleRules = DocsStyleRules();
// The rules that name a class, with `media` null for the plain ones and "min-width" / "max-width"
// for the ones a media query switches on. The last one wins where they overlap, as in a stylesheet.
function RulesFor(className, media = null) {
return styleRules.filter((rule) =>
rule.selector.split(",").some((name) => name.trim() === className) &&
(media === null ? rule.media === null : Boolean(rule.media) && rule.media.includes(media))
);
}
// A `padding:` shorthand spread over its four sides, the way the browser reads it.
function PaddingOf(rule) {
const shorthand = rule.declarations.match(/(?:^|[;\s])padding:\s*([^;]+)/);
assert.ok(shorthand, `the ${rule.selector} rule sets no padding to compare`);
const values = shorthand[1].trim().split(/\s+/).map((value) => parseFloat(value));
assert.ok(
values.length <= 4 && values.every((value) => Number.isFinite(value)),
`only px padding is compared here, ${rule.selector} has "${shorthand[1].trim()}"`
);
return {
top: values[0],
right: values[1] ?? values[0],
bottom: values[2] ?? values[0],
left: values[3] ?? values[1] ?? values[0],
};
}
test("the two asides are as tall as the page they stand beside", () => {
for (const className of [".docs-sidebar", ".docs-sections"]) {
const aside = RulesFor(className).find((rule) => /position:\s*sticky/.test(rule.declarations));
assert.ok(aside, `${className} has to stay beside the text while the page scrolls`);
assert.match(aside.declarations, /height:\s*100vh/, `${className} has to fill the page, not just its own contents`);
assert.doesNotMatch(aside.declarations, /max-height/, `${className} is capped at a screen height by 'height'`);
}
});
test("a narrow window stacks the columns and lets each one be its own height", () => {
const stacked = RulesFor(".docs-sidebar", "max-width");
assert.equal(stacked.length, 1, "the stacked layout is set by one rule");
assert.match(stacked[0].declarations, /position:\s*static/, "a stacked sidebar does not follow the scroll");
assert.match(stacked[0].declarations, /height:\s*auto/, "…and it is not held at a screen height either");
});
test("the reading column is centred in the space left beside the sidebar", () => {
const reading = RulesFor(".docs-article").find((rule) => /max-width:/.test(rule.declarations));
assert.ok(reading, "the text has to be capped in width to be readable");
assert.match(reading.declarations, /margin-inline:\s*auto/, "…and centred in the space left beside the sidebar");
assert.match(reading.selector, /\.docs-pager/, "the pager under the text follows the same column");
});
test("a very wide window keeps the sections next to the text, not at the edge of the screen", () => {
const centred = RulesFor(".docs", "min-width");
assert.equal(centred.length, 1, "one wide window rule centres the documentation");
assert.match(centred[0].declarations, /justify-content:\s*center/);
const wider = Number(centred[0].media.match(/min-width:\s*(\d+)/)[1]);
assert.ok(wider >= 1400, `${wider}px is not a wide window: the layout breaks before that`);
const main = RulesFor(".docs-main", "min-width");
assert.equal(main.length, 1, "the main column is capped once the window is wide");
assert.match(main[0].declarations, /flex:\s*0 1 \d+px/, "…so it stops growing and the sections sit next to it");
});
test("the sections aside has more room around its links than the sidebar has", () => {
const shared = RulesFor(".docs-sidebar").find((rule) => /padding:/.test(rule.declarations));
const sections = RulesFor(".docs-sections").filter((rule) => /padding:/.test(rule.declarations)).pop();
assert.ok(sections && sections !== shared, "the sections aside sets its own padding");
const room = PaddingOf(sections);
const sidebar = PaddingOf(shared);
for (const side of ["top", "right", "bottom", "left"]) {
assert.ok(room[side] >= sidebar[side], `the sections aside is tighter than the sidebar on the ${side}`);
}
assert.ok(
["top", "right", "bottom", "left"].some((side) => room[side] > sidebar[side]),
"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) => {
@@ -280,6 +282,8 @@ function loadFoundryWriters({ seed = {} } = {}) {
if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../models/Campaign") return { findOne: async () => campaign };
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/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`);
}; };
@@ -327,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) => {
@@ -141,6 +143,8 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../models/Campaign") return { findOne: async () => campaign };
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/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`);
}; };
@@ -415,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
@@ -471,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,
}; };
@@ -574,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; } },
@@ -627,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");
@@ -735,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

View File

@@ -341,6 +341,17 @@ function mapViewerTokenWiringTests() {
assert.match(pane, /@contextmenu\.stop\.prevent="onTokenContextMenu\(token\)"/); assert.match(pane, /@contextmenu\.stop\.prevent="onTokenContextMenu\(token\)"/);
}); });
test("double clicking a token opens its actor's character sheet", () => {
assert.match(pane, /@dblclick="openTokenSheet\(token\)"/);
// The sheet is opened for the actor behind the token, and only when that actor is known.
assert.match(pane, /function openTokenSheet\(token\) \{[^}]*tokenActor\(token\)[^}]*openActorSheet\(/);
// A single click is not the trigger: it lands on the token at the end of every drag, so
// moving a token would open its sheet every time.
assert.doesNotMatch(pane, /@click="openTokenSheet\(/);
// The keyboard reaches the same sheet: Enter on a focused token, like its arrow keys.
assert.match(pane, /if \(event\.key === 'Enter'\) openTokenSheet\(token\);/);
});
test("tokens are saved and taken off through the map routes", () => { test("tokens are saved and taken off through the map routes", () => {
assert.match(pane, /['"]\/map\/place-token['"]/); assert.match(pane, /['"]\/map\/place-token['"]/);
assert.match(pane, /['"]\/map\/remove-token['"]/); assert.match(pane, /['"]\/map\/remove-token['"]/);

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