Merge branch 'main' into bug/103-enrich-htmlfield-content-before-its-used-in-applications

module/applications/sheets/actors/character.mjs

@@ -27,7 +27,12 @@ export default class CharacterSheet extends DHBaseActorSheet {
         window: {
             resizable: true
         },
-        dragDrop: [],
+        dragDrop: [
+            {
+                dragSelector: '[data-item-id][draggable="true"]',
+                dropSelector: null
+            }
+        ],
         contextMenus: [{
             handler: CharacterSheet.#getDomainCardContextOptions,
             selector: '[data-item-uuid][data-type="domainCard"]',
@@ -599,7 +604,59 @@ export default class CharacterSheet extends DHBaseActorSheet {
         await doc?.update({ 'system.inVault': !doc.system.inVault });
     }
 
+    /**
+     * Use a item
+     * @type {ApplicationClickAction}
+     */
+    static async useItem(event, button) {
+        const item = this.getItem(button);
+        if (!item) return;
+
+        // Should dandle its actions. Or maybe they'll be separate buttons as per an Issue on the board
+        if (item.type === 'feature') {
+            item.use(event);
+        } else if (item instanceof ActiveEffect) {
+            item.toChat(this);
+        } else {
+            const wasUsed = await item.use(event);
+            if (wasUsed && item.type === 'weapon') {
+                Hooks.callAll(CONFIG.DH.HOOKS.characterAttack, {});
+            }
+        }
+    }
+
+    /**
+     * Use an action
+     * @type {ApplicationClickAction}
+     */
+    static async useAction(event, button) {
+        const item = this.getItem(button);
+        if (!item) return;
+
+        const action = item.system.actions.find(x => x.id === button.dataset.actionId);
+        if (!action) return;
+
+        action.use(event);
+    }
+
+    async _onDragStart(event) {
+        const item = this.getItem(event);
+        
+        const dragData = {
+            type: item.documentName,
+            uuid: item.uuid
+        };
+        
+        event.dataTransfer.setData('text/plain', JSON.stringify(dragData));
+        
+        super._onDragStart(event);
+    }
+
     async _onDrop(event) {
+        // Prevent event bubbling to avoid duplicate handling
+        event.preventDefault();
+        event.stopPropagation();
+        
         super._onDrop(event);
         this._onDropItem(event, TextEditor.getDragEventData(event));
     }

module/applications/sheets/api/_modules.mjs

@@ -1,5 +1,6 @@
 export { default as DHApplicationMixin } from './application-mixin.mjs';
 export { default as DHBaseItemSheet } from './base-item.mjs';
 export { default as DHHeritageSheet } from './heritage-sheet.mjs';
+export { default as DHItemAttachmentSheet } from './item-attachment-sheet.mjs';
 export { default as DHBaseActorSheet } from './base-actor.mjs';
 export { default as DHBaseActorSettings } from './actor-setting.mjs';

module/applications/sheets/api/base-actor.mjs

@@ -126,7 +126,7 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
 
         const systemData = {
             name: game.i18n.localize('DAGGERHEART.GENERAL.Experience.single'),
-            description: `${experience.name} ${experience.total < 0 ? experience.total : `+${experience.total}`}`
+            description: `${experience.name} ${experience.value.signedString()}`
         };
 
         foundry.documents.ChatMessage.implementation.create({

module/applications/sheets/api/item-attachment-sheet.mjs

@@ -0,0 +1,90 @@
+
+export default function ItemAttachmentSheet(Base) {
+    return class extends Base {
+        static DEFAULT_OPTIONS = {
+            ...super.DEFAULT_OPTIONS,
+            dragDrop: [
+                ...(super.DEFAULT_OPTIONS.dragDrop || []),
+                { dragSelector: null, dropSelector: '.attachments-section' }
+            ],
+            actions: {
+                ...super.DEFAULT_OPTIONS.actions,
+                removeAttachment: this.#removeAttachment
+            }
+        };
+
+        static PARTS = {
+            ...super.PARTS,
+            attachments: {
+                template: 'systems/daggerheart/templates/sheets/global/tabs/tab-attachments.hbs',
+                scrollable: ['.attachments']
+            }
+        };
+
+        static TABS = {
+            ...super.TABS,
+            primary: {
+                ...super.TABS?.primary,
+                tabs: [
+                    ...(super.TABS?.primary?.tabs || []),
+                    { id: 'attachments' }
+                ],
+                initial: super.TABS?.primary?.initial || 'description',
+                labelPrefix: super.TABS?.primary?.labelPrefix || 'DAGGERHEART.GENERAL.Tabs'
+            }
+        };
+
+        async _preparePartContext(partId, context) {
+            await super._preparePartContext(partId, context);
+
+            if (partId === 'attachments') {
+                context.attachedItems = await prepareAttachmentContext(this.document);
+            }
+
+            return context;
+        }
+
+        async _onDrop(event) {
+            const data = TextEditor.getDragEventData(event);
+            
+            const attachmentsSection = event.target.closest('.attachments-section');
+            if (!attachmentsSection) return super._onDrop(event);
+            
+            event.preventDefault();
+            event.stopPropagation();
+            
+            const item = await Item.implementation.fromDropData(data);
+            if (!item) return;
+            
+            // Call the data model's public method
+            await this.document.system.addAttachment(item);
+        }
+
+
+        static async #removeAttachment(event, target) {
+            // Call the data model's public method
+            await this.document.system.removeAttachment(target.dataset.uuid);
+}
+
+        async _preparePartContext(partId, context) {
+            await super._preparePartContext(partId, context);
+            
+            if (partId === 'attachments') {
+                // Keep this simple UI preparation in the mixin
+                const attachedUUIDs = this.document.system.attached;
+                context.attachedItems = await Promise.all(
+                    attachedUUIDs.map(async uuid => {
+                        const item = await fromUuid(uuid);
+                        return {
+                            uuid: uuid,
+                            name: item?.name || 'Unknown Item',
+                            img: item?.img || 'icons/svg/item-bag.svg'
+                        };
+                    })
+                );
+            }
+            
+            return context;
+        }
+    };
+}

module/applications/sheets/items/armor.mjs

@@ -1,10 +1,10 @@
 import DHBaseItemSheet from '../api/base-item.mjs';
+import ItemAttachmentSheet from '../api/item-attachment-sheet.mjs';
 
-export default class ArmorSheet extends DHBaseItemSheet {
+export default class ArmorSheet extends ItemAttachmentSheet(DHBaseItemSheet) {
     /**@inheritdoc */
     static DEFAULT_OPTIONS = {
         classes: ['armor'],
-        dragDrop: [{ dragSelector: null, dropSelector: null }],
         tagifyConfigs: [
             {
                 selector: '.features-input',
@@ -30,7 +30,8 @@ export default class ArmorSheet extends DHBaseItemSheet {
         effects: {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
             scrollable: ['.effects']
-        }
+        },
+        ...super.PARTS,
     };
 
     /**@inheritdoc */

module/applications/sheets/items/weapon.mjs

@@ -1,6 +1,7 @@
 import DHBaseItemSheet from '../api/base-item.mjs';
+import ItemAttachmentSheet from '../api/item-attachment-sheet.mjs';
 
-export default class WeaponSheet extends DHBaseItemSheet {
+export default class WeaponSheet extends ItemAttachmentSheet(DHBaseItemSheet) {
     /**@inheritdoc */
     static DEFAULT_OPTIONS = {
         classes: ['weapon'],
@@ -29,12 +30,13 @@ export default class WeaponSheet extends DHBaseItemSheet {
         effects: {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
             scrollable: ['.effects']
-        }
+        },
+        ...super.PARTS,
     };
 
     /**@inheritdoc */
     async _preparePartContext(partId, context) {
-        super._preparePartContext(partId, context);
+        await super._preparePartContext(partId, context);
         switch (partId) {
             case 'settings':
                 context.features = this.document.system.weaponFeatures.map(x => x.value);