Added CountdownEdit view

module/applications/dialogs/ownershipSelection.mjs

@@ -1,13 +1,12 @@
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
 export default class OwnershipSelection extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(resolve, reject, name, ownership) {
+    constructor(name, ownership, defaultOwnership) {
         super({});
 
-        this.resolve = resolve;
-        this.reject = reject;
         this.name = name;
-        this.ownership = ownership;
+        this.ownership = foundry.utils.deepClone(ownership);
+        this.defaultOwnership = defaultOwnership;
     }
 
     static DEFAULT_OPTIONS = {
@@ -30,43 +29,48 @@ export default class OwnershipSelection extends HandlebarsApplicationMixin(Appli
         return game.i18n.format('DAGGERHEART.APPLICATIONS.OwnershipSelection.title', { name: this.name });
     }
 
+    getOwnershipData(id) {
+        return this.ownership[id] ?? CONST.DOCUMENT_OWNERSHIP_LEVELS.INHERIT;
+    }
+
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
-        context.ownershipOptions = Object.keys(CONST.DOCUMENT_OWNERSHIP_LEVELS).map(level => ({
-            value: CONST.DOCUMENT_OWNERSHIP_LEVELS[level],
-            label: game.i18n.localize(`OWNERSHIP.${level}`)
-        }));
-        context.ownership = {
-            default: this.ownership.default,
-            players: Object.keys(this.ownership.players).reduce((acc, x) => {
-                const user = game.users.get(x);
-                if (!user.isGM) {
-                    acc[x] = {
-                        img: user.character?.img ?? 'icons/svg/cowled.svg',
-                        name: user.name,
-                        ownership: this.ownership.players[x].value
-                    };
-                }
+        context.ownershipDefaultOptions = CONFIG.DH.GENERAL.basicOwnershiplevels;
+        context.ownershipOptions = CONFIG.DH.GENERAL.simpleOwnershiplevels;
+        context.defaultOwnership = this.defaultOwnership;
+        context.ownership = game.users.reduce((acc, user) => {
+            if (!user.isGM) {
+                acc[user.id] = {
+                    ...user,
+                    img: user.character?.img ?? 'icons/svg/cowled.svg',
+                    ownership: this.getOwnershipData(user.id)
+                };
+            }
 
-                return acc;
-            }, {})
-        };
+            return acc;
+        }, {});
 
         return context;
     }
 
     static async updateData(event, _, formData) {
-        const { ownership } = foundry.utils.expandObject(formData.object);
-
-        this.resolve(ownership);
-        this.close(true);
+        const data = foundry.utils.expandObject(formData.object);
+        this.close(data);
     }
 
-    async close(fromSave) {
-        if (!fromSave) {
-            this.reject();
+    async close(data) {
+        if (data) {
+            this.saveData = data;
         }
 
         await super.close();
     }
+
+    static async configure(name, ownership, defaultOwnership) {
+        return new Promise(resolve => {
+            const app = new this(name, ownership, defaultOwnership);
+            app.addEventListener('close', () => resolve(app.saveData), { once: true });
+            app.render({ force: true });
+        });
+    }
 }

module/applications/sidebar/tabs/daggerheartMenu.mjs

@@ -29,7 +29,8 @@ export default class DaggerheartMenu extends HandlebarsApplicationMixin(Abstract
         },
         actions: {
             selectRefreshable: DaggerheartMenu.#selectRefreshable,
-            refreshActors: DaggerheartMenu.#refreshActors
+            refreshActors: DaggerheartMenu.#refreshActors,
+            editCountdowns: DaggerheartMenu.#editCountdowns
         }
     };
 
@@ -157,4 +158,8 @@ export default class DaggerheartMenu extends HandlebarsApplicationMixin(Abstract
 
         this.render();
     }
+
+    static async #editCountdowns() {
+        new game.system.api.applications.ui.CountdownEdit().render(true);
+    }
 }

module/applications/ui/_module.mjs

@@ -1,3 +1,4 @@
+export { default as CountdownEdit } from './countdownEdit.mjs';
 export { default as DhChatLog } from './chatLog.mjs';
 export { default as DhCombatTracker } from './combatTracker.mjs';
 export * as DhCountdowns from './countdowns.mjs';

module/applications/ui/countdownEdit.mjs

@@ -0,0 +1,129 @@
+import { DhCountdown } from '../../data/countdowns.mjs';
+
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
+
+export default class CountdownEdit extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor() {
+        super();
+
+        this.data = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns);
+        this.editingCountdowns = new Set();
+    }
+
+    get title() {
+        return game.i18n.localize('DAGGERHEART.APPLICATIONS.CountdownEdit.title');
+    }
+
+    static DEFAULT_OPTIONS = {
+        classes: ['daggerheart', 'dh-style', 'countdown-edit'],
+        tag: 'form',
+        position: { width: 600 },
+        window: { icon: 'fa-solid fa-clock-rotate-left' },
+        actions: {
+            addCountdown: CountdownEdit.#addCountdown,
+            toggleCountdownEdit: CountdownEdit.#toggleCountdownEdit,
+            editCountdownImage: CountdownEdit.#editCountdownImage,
+            editCountdownOwnership: CountdownEdit.#editCountdownOwnership,
+            removeCountdown: CountdownEdit.#removeCountdown
+        },
+        form: { handler: this.updateData, submitOnChange: true }
+    };
+
+    static PARTS = {
+        countdowns: {
+            template: 'systems/daggerheart/templates/ui/countdown-edit.hbs',
+            scrollable: ['.expanded-view']
+        }
+    };
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.ownershipDefaultOptions = CONFIG.DH.GENERAL.basicOwnershiplevels;
+        context.defaultOwnership = this.data.defaultOwnership;
+        context.countdownBaseTypes = CONFIG.DH.GENERAL.countdownBaseTypes;
+        context.countdownTypes = CONFIG.DH.GENERAL.countdownTypes;
+        context.countdowns = Object.keys(this.data.countdowns).reduce((acc, key) => {
+            const countdown = this.data.countdowns[key];
+            acc[key] = {
+                ...countdown,
+                typeName: game.i18n.localize(CONFIG.DH.GENERAL.countdownBaseTypes[countdown.type].name),
+                progress: {
+                    ...countdown.progress,
+                    typeName: game.i18n.localize(CONFIG.DH.GENERAL.countdownTypes[countdown.progress.type].label)
+                },
+                editing: this.editingCountdowns.has(key)
+            };
+
+            return acc;
+        }, {});
+
+        return context;
+    }
+
+    async updateSetting(update) {
+        await this.data.updateSource(update);
+        await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, this.data);
+        this.render();
+    }
+
+    static async updateData(_event, _, formData) {
+        this.updateSetting(foundry.utils.expandObject(formData.object));
+    }
+
+    static #addCountdown() {
+        this.updateSetting({
+            [`countdowns.${foundry.utils.randomID()}`]: DhCountdown.defaultCountdown()
+        });
+    }
+
+    static #editCountdownImage(_, target) {
+        const countdown = this.data.countdowns[target.id];
+        const fp = new foundry.applications.apps.FilePicker.implementation({
+            current: countdown.img,
+            type: 'image',
+            callback: async path => this.updateSetting({ [`countdowns.${target.id}.img`]: path }),
+            top: this.position.top + 40,
+            left: this.position.left + 10
+        });
+        return fp.browse();
+    }
+
+    static #toggleCountdownEdit(_, button) {
+        const { countdownId } = button.dataset;
+
+        const isEditing = this.editingCountdowns.has(countdownId);
+        if (isEditing) this.editingCountdowns.delete(countdownId);
+        else this.editingCountdowns.add(countdownId);
+
+        this.render();
+    }
+
+    static async #editCountdownOwnership(_, button) {
+        const countdown = this.data.countdowns[button.dataset.countdownId];
+        const data = await game.system.api.applications.dialogs.OwnershipSelection.configure(
+            countdown.name,
+            countdown.ownership,
+            this.data.defaultOwnership
+        );
+        if (!data) return;
+
+        this.updateSetting({ [`countdowns.${button.dataset.countdownId}`]: data });
+    }
+
+    static async #removeCountdown(_, button) {
+        const { countdownId } = button.dataset;
+
+        const confirmed = await foundry.applications.api.DialogV2.confirm({
+            window: {
+                title: game.i18n.localize('DAGGERHEART.APPLICATIONS.CountdownEdit.removeCountdownTitle')
+            },
+            content: game.i18n.format('DAGGERHEART.APPLICATIONS.CountdownEdit.removeCountdownText', {
+                name: this.data.countdowns[countdownId].name
+            })
+        });
+        if (!confirmed) return;
+
+        if (this.editingCountdowns.has(countdownId)) this.editingCountdowns.delete(countdownId);
+        this.updateSetting({ [`countdowns.-=${countdownId}`]: null });
+    }
+}