daggerheart/module/applications/sheets-configs/token-config.mjs

export default class DhTokenConfig extends foundry.applications.sheets.TokenConfig {
    /** @override */
    static PARTS = {
        tabs: super.PARTS.tabs,
        identity: super.PARTS.identity,
        appearance: {
            template: 'systems/daggerheart/templates/sheets-settings/token-config/appearance.hbs',
            scrollable: ['']
        },
        vision: super.PARTS.vision,
        light: super.PARTS.light,
        resources: super.PARTS.resources,
        footer: super.PARTS.footer
    };

    /** @inheritDoc */
    async _prepareResourcesTab() {
        const token = this.token;
        const usesTrackableAttributes = !foundry.utils.isEmpty(CONFIG.Actor.trackableAttributes);
        const attributeSource =
            this.actor?.system instanceof foundry.abstract.DataModel && usesTrackableAttributes
                ? this.actor?.type
                : this.actor?.system;
        const TokenDocument = foundry.utils.getDocumentClass('Token');
        const attributes = TokenDocument.getTrackedAttributes(attributeSource);
        return {
            barAttributes: TokenDocument.getTrackedAttributeChoices(attributes, attributeSource),
            bar1: token.getBarAttribute?.('bar1'),
            bar2: token.getBarAttribute?.('bar2'),
            turnMarkerModes: DhTokenConfig.TURN_MARKER_MODES,
            turnMarkerAnimations: CONFIG.Combat.settings.turnMarkerAnimations
        };
    }

    async _prepareAppearanceTab() {
        const context = await super._prepareAppearanceTab();
        context.tokenSizes = CONFIG.DH.ACTOR.tokenSize;
        context.usesActorSize = this.token.actor?.system?.metadata?.usesSize;
        context.actorSizeDisable = context.usesActorSize && this.token.actor.system.size !== 'custom';

        return context;
    }

    _attachPartListeners(partId, htmlElement, options) {
        super._attachPartListeners(partId, htmlElement, options);

        switch (partId) {
            case 'appearance':
                htmlElement
                    .querySelector('#dhTokenSize')
                    ?.addEventListener('change', this.onTokenSizeChange.bind(this));
                break;
        }
    }

    async onTokenSizeChange(event) {
        const value = event.target.value;
        const tokenSizeDimensions = this.element.querySelector('#tokenSizeDimensions');
        if (tokenSizeDimensions) {
            const disabled = value !== 'custom';

            tokenSizeDimensions.dataset.tooltip = disabled
                ? game.i18n.localize('DAGGERHEART.APPLICATIONS.TokenConfig.actorSizeUsed')
                : '';

            const disabledIcon = tokenSizeDimensions.querySelector('i');
            if (disabledIcon) {
                disabledIcon.style.opacity = disabled ? '' : '0';
            }

            const dimensionsInputs = tokenSizeDimensions.querySelectorAll('.form-fields input');
            for (const input of dimensionsInputs) {
                input.disabled = disabled;
            }
        }
    }

    async _processSubmitData(event, form, submitData, options) {
        const tokenSizeSelect = this.element.querySelector('#dhTokenSize');
        if (tokenSizeSelect && this.token.actor) {
            if (tokenSizeSelect.value !== this.token.actor.system.size) {
                this.token.actor.update({ 'system.size': tokenSizeSelect.value });
            }
        }

        super._processSubmitData(event, form, submitData, options);
    }
}