1867 lines
91 KiB
JavaScript
1867 lines
91 KiB
JavaScript
/**
|
||
* Dog Calorie Calculator - iframe version
|
||
* by Canine Nutrition and Wellness
|
||
*/
|
||
|
||
class DogCalorieCalculator {
|
||
constructor() {
|
||
this.currentMER = 0;
|
||
this.currentMERMin = 0; // For range calculations
|
||
this.currentMERMax = 0; // For range calculations
|
||
this.isImperial = false;
|
||
this.theme = this.getThemeFromURL() || CALCULATOR_CONFIG.defaultTheme;
|
||
this.scale = this.getScaleFromURL() || CALCULATOR_CONFIG.defaultScale;
|
||
this.foodSources = [];
|
||
this.maxFoodSources = CALCULATOR_CONFIG.maxFoodSources;
|
||
this.mealsPerDay = 2;
|
||
this.showPerMeal = false;
|
||
// Kayafied reference source tracking
|
||
this.kibbleRefId = null;
|
||
this.gcRefId = null;
|
||
this.init();
|
||
}
|
||
|
||
init() {
|
||
this.applyTheme();
|
||
this.applyScale();
|
||
this.initializeFoodSources();
|
||
this.bindEvents();
|
||
this.updateUnitLabels();
|
||
this.setupIframeResize();
|
||
|
||
// Show the calculator with fade-in
|
||
const container = document.getElementById('dogCalculator');
|
||
container.classList.add('loaded');
|
||
}
|
||
|
||
getThemeFromURL() {
|
||
const urlParams = new URLSearchParams(window.location.search);
|
||
const theme = urlParams.get('theme');
|
||
return ['light', 'dark', 'system'].includes(theme) ? theme : null;
|
||
}
|
||
|
||
getScaleFromURL() {
|
||
const urlParams = new URLSearchParams(window.location.search);
|
||
const scale = parseFloat(urlParams.get('scale'));
|
||
return (!isNaN(scale) && scale >= CALCULATOR_CONFIG.minScale && scale <= CALCULATOR_CONFIG.maxScale) ? scale : null;
|
||
}
|
||
|
||
applyTheme() {
|
||
const container = document.getElementById('dogCalculator');
|
||
container.classList.remove('theme-light', 'theme-dark', 'theme-system');
|
||
container.classList.add('theme-' + this.theme);
|
||
}
|
||
|
||
applyScale() {
|
||
const container = document.getElementById('dogCalculator');
|
||
if (!container) return;
|
||
|
||
// Clamp scale between min and max for usability
|
||
const clampedScale = Math.max(CALCULATOR_CONFIG.minScale, Math.min(CALCULATOR_CONFIG.maxScale, this.scale));
|
||
|
||
if (clampedScale !== 1.0) {
|
||
container.style.transform = `scale(${clampedScale})`;
|
||
container.style.transformOrigin = 'top center';
|
||
|
||
// Recalculate height for parent without adding artificial margins
|
||
setTimeout(() => {
|
||
this.sendHeightToParent();
|
||
}, 100);
|
||
}
|
||
}
|
||
|
||
// Food Source Management Methods
|
||
initializeFoodSources() {
|
||
// Seed three sources for Kaya's transition
|
||
const gc = {
|
||
id: this.generateFoodSourceId(),
|
||
name: 'Fred & Felia, gently cooked',
|
||
energy: '115',
|
||
energyUnit: 'kcal100g',
|
||
percentage: 5,
|
||
isLocked: false
|
||
};
|
||
this.foodSources.push(gc);
|
||
this.renderFoodSource(gc);
|
||
this.gcRefId = gc.id;
|
||
|
||
const kibble = {
|
||
id: this.generateFoodSourceId(),
|
||
name: 'Eukanuba, kibble',
|
||
energy: '372',
|
||
energyUnit: 'kcal100g',
|
||
percentage: 95,
|
||
isLocked: false
|
||
};
|
||
this.foodSources.push(kibble);
|
||
this.renderFoodSource(kibble);
|
||
this.kibbleRefId = kibble.id;
|
||
|
||
const treats = {
|
||
id: this.generateFoodSourceId(),
|
||
name: 'Treats',
|
||
energy: '',
|
||
energyUnit: 'kcal100g',
|
||
percentage: 0,
|
||
isLocked: false
|
||
};
|
||
this.foodSources.push(treats);
|
||
this.renderFoodSource(treats);
|
||
|
||
this.updateAddButton();
|
||
this.updateRemoveButtons();
|
||
this.refreshAllPercentageUI();
|
||
}
|
||
|
||
addFoodSource() {
|
||
if (this.foodSources.length >= this.maxFoodSources) {
|
||
return;
|
||
}
|
||
|
||
const id = this.generateFoodSourceId();
|
||
const foodSource = {
|
||
id: id,
|
||
name: `Food Source ${this.foodSources.length + 1}`,
|
||
energy: '',
|
||
energyUnit: this.isImperial ? 'kcalcup' : 'kcal100g',
|
||
percentage: this.foodSources.length === 0 ? 100 : 0,
|
||
isLocked: false
|
||
};
|
||
|
||
this.foodSources.push(foodSource);
|
||
this.redistributePercentages();
|
||
this.renderFoodSource(foodSource);
|
||
this.updateAddButton();
|
||
this.updateRemoveButtons();
|
||
this.refreshAllPercentageUI();
|
||
}
|
||
|
||
removeFoodSource(id) {
|
||
if (this.foodSources.length <= 1) {
|
||
return; // Cannot remove the last food source
|
||
}
|
||
|
||
const index = this.foodSources.findIndex(fs => fs.id === id);
|
||
if (index === -1) return;
|
||
|
||
this.foodSources.splice(index, 1);
|
||
// If reference IDs were removed, clear them
|
||
if (this.kibbleRefId === id) this.kibbleRefId = null;
|
||
if (this.gcRefId === id) this.gcRefId = null;
|
||
|
||
// Remove the DOM element
|
||
const element = document.getElementById(`foodSource-${id}`);
|
||
if (element) {
|
||
element.remove();
|
||
}
|
||
|
||
// Redistribute percentages among remaining sources
|
||
this.redistributePercentages();
|
||
this.updateFoodSourceNames();
|
||
this.updateAddButton();
|
||
this.updateRemoveButtons();
|
||
this.refreshAllPercentageUI();
|
||
this.updateCalorieCalculations();
|
||
}
|
||
|
||
generateFoodSourceId() {
|
||
return 'fs_' + Date.now() + '_' + Math.random().toString(36).substr(2, 5);
|
||
}
|
||
|
||
redistributePercentages() {
|
||
const count = this.foodSources.length;
|
||
if (count === 0) return;
|
||
|
||
// Only redistribute among unlocked sources
|
||
const unlockedSources = this.foodSources.filter(fs => !fs.isLocked);
|
||
const lockedSources = this.foodSources.filter(fs => fs.isLocked);
|
||
|
||
// Calculate total locked percentage
|
||
const totalLockedPercentage = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
// Available percentage for unlocked sources
|
||
const availablePercentage = 100 - totalLockedPercentage;
|
||
|
||
if (unlockedSources.length > 0) {
|
||
const equalPercentage = Math.floor(availablePercentage / unlockedSources.length);
|
||
const remainder = availablePercentage - (equalPercentage * unlockedSources.length);
|
||
|
||
unlockedSources.forEach((fs, index) => {
|
||
fs.percentage = equalPercentage + (index < remainder ? 1 : 0);
|
||
});
|
||
}
|
||
|
||
// Update the UI sliders and inputs
|
||
this.refreshAllPercentageUI();
|
||
}
|
||
|
||
// OBSOLETE METHODS - Replaced by new validation system
|
||
// Keeping for reference but these are no longer used
|
||
|
||
/*
|
||
updatePercentageInputs() {
|
||
this.foodSources.forEach(fs => {
|
||
const slider = document.getElementById(`percentage-slider-${fs.id}`);
|
||
const input = document.getElementById(`percentage-input-${fs.id}`);
|
||
const display = document.getElementById(`percentage-display-${fs.id}`);
|
||
|
||
if (slider) slider.value = fs.percentage;
|
||
if (input) input.value = fs.percentage;
|
||
if (display) display.textContent = `${fs.percentage}%`;
|
||
});
|
||
|
||
// Update constraints after values are set
|
||
this.updatePercentageConstraints();
|
||
}
|
||
|
||
updatePercentageConstraints() {
|
||
this.foodSources.forEach(fs => {
|
||
const slider = document.getElementById(`percentage-slider-${fs.id}`);
|
||
const input = document.getElementById(`percentage-input-${fs.id}`);
|
||
|
||
if (!slider || !input) return;
|
||
|
||
// Always keep full 0-100 scale for all sliders
|
||
slider.max = 100;
|
||
input.max = 100;
|
||
|
||
if (fs.isLocked) {
|
||
// Locked sources can't be changed
|
||
slider.disabled = true;
|
||
input.disabled = true;
|
||
} else {
|
||
// Calculate the maximum this source can have
|
||
const lockedSources = this.foodSources.filter(other => other.id !== fs.id && other.isLocked);
|
||
const totalLockedPercentage = lockedSources.reduce((sum, other) => sum + other.percentage, 0);
|
||
const maxAllowed = 100 - totalLockedPercentage;
|
||
|
||
// Re-enable
|
||
slider.disabled = false;
|
||
input.disabled = false;
|
||
|
||
// Store max allowed for validation (we'll check this in event handlers)
|
||
slider.dataset.maxAllowed = maxAllowed;
|
||
input.dataset.maxAllowed = maxAllowed;
|
||
|
||
// If current value exceeds max, adjust it
|
||
if (fs.percentage > maxAllowed) {
|
||
fs.percentage = maxAllowed;
|
||
slider.value = maxAllowed;
|
||
input.value = maxAllowed;
|
||
document.getElementById(`percentage-display-${fs.id}`).textContent = `${maxAllowed}%`;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
adjustPercentages(changedId, newPercentage) {
|
||
const changedIndex = this.foodSources.findIndex(fs => fs.id === changedId);
|
||
if (changedIndex === -1) return;
|
||
|
||
const oldPercentage = this.foodSources[changedIndex].percentage;
|
||
const difference = newPercentage - oldPercentage;
|
||
|
||
this.foodSources[changedIndex].percentage = newPercentage;
|
||
|
||
// Only redistribute among unlocked sources (excluding the changed one)
|
||
const otherUnlockedSources = this.foodSources.filter((fs, index) =>
|
||
index !== changedIndex && !fs.isLocked
|
||
);
|
||
|
||
// If this is the only unlocked source, force it to fill remaining percentage
|
||
if (otherUnlockedSources.length === 0) {
|
||
const lockedSources = this.foodSources.filter((fs, index) =>
|
||
index !== changedIndex && fs.isLocked
|
||
);
|
||
const totalLockedPercentage = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
const requiredPercentage = 100 - totalLockedPercentage;
|
||
|
||
// Force the changed source to the required percentage
|
||
this.foodSources[changedIndex].percentage = requiredPercentage;
|
||
this.updatePercentageInputs();
|
||
this.updateFoodCalculations();
|
||
return;
|
||
}
|
||
|
||
// Calculate total locked percentage (excluding the changed source)
|
||
const lockedSources = this.foodSources.filter((fs, index) =>
|
||
index !== changedIndex && fs.isLocked
|
||
);
|
||
const totalLockedPercentage = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
// Available percentage for unlocked sources
|
||
const availablePercentage = 100 - newPercentage - totalLockedPercentage;
|
||
|
||
const totalUnlockedPercentage = otherUnlockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
if (totalUnlockedPercentage === 0) {
|
||
// If all other unlocked sources are 0, distribute equally
|
||
const equalShare = Math.floor(availablePercentage / otherUnlockedSources.length);
|
||
const remainder = availablePercentage - (equalShare * otherUnlockedSources.length);
|
||
|
||
otherUnlockedSources.forEach((fs, index) => {
|
||
fs.percentage = equalShare + (index < remainder ? 1 : 0);
|
||
});
|
||
} else {
|
||
// Distribute proportionally among unlocked sources
|
||
const scale = availablePercentage / totalUnlockedPercentage;
|
||
|
||
let distributedTotal = 0;
|
||
otherUnlockedSources.forEach((fs, index) => {
|
||
if (index === otherUnlockedSources.length - 1) {
|
||
// Last item gets the remainder to ensure exact 100%
|
||
fs.percentage = availablePercentage - distributedTotal;
|
||
} else {
|
||
fs.percentage = Math.round(fs.percentage * scale);
|
||
distributedTotal += fs.percentage;
|
||
}
|
||
});
|
||
}
|
||
|
||
this.updatePercentageInputs();
|
||
this.updateFoodCalculations();
|
||
}
|
||
*/
|
||
|
||
// New validation system methods
|
||
validatePercentageChange(sourceId, requestedValue) {
|
||
// Find the source being changed
|
||
const changedSource = this.foodSources.find(fs => fs.id === sourceId);
|
||
if (!changedSource) {
|
||
return { isValid: false, reason: 'Source not found' };
|
||
}
|
||
|
||
// If the source is locked, no change allowed
|
||
if (changedSource.isLocked) {
|
||
return { isValid: false, reason: 'Source is locked' };
|
||
}
|
||
|
||
// Ensure requested value is within bounds
|
||
const clampedValue = Math.max(0, Math.min(100, requestedValue));
|
||
|
||
// Calculate locked and other unlocked totals
|
||
const lockedSources = this.foodSources.filter(fs => fs.id !== sourceId && fs.isLocked);
|
||
const otherUnlockedSources = this.foodSources.filter(fs => fs.id !== sourceId && !fs.isLocked);
|
||
|
||
const totalLocked = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
// Check if the only unlocked source
|
||
if (otherUnlockedSources.length === 0) {
|
||
// This is the only unlocked source, must fill remaining percentage
|
||
const requiredPercentage = 100 - totalLocked;
|
||
return {
|
||
isValid: true,
|
||
actualValue: requiredPercentage,
|
||
affectedSources: [{ id: sourceId, newPercentage: requiredPercentage }],
|
||
reason: 'Only unlocked source, forced to fill remainder'
|
||
};
|
||
}
|
||
|
||
// Calculate available percentage for redistribution
|
||
const availableForOthers = 100 - clampedValue - totalLocked;
|
||
|
||
// Check if redistribution is possible
|
||
if (availableForOthers < 0) {
|
||
// Cannot accommodate this value
|
||
const maxAllowed = 100 - totalLocked;
|
||
return {
|
||
isValid: true,
|
||
actualValue: maxAllowed,
|
||
affectedSources: this.calculateRedistribution(sourceId, maxAllowed, otherUnlockedSources),
|
||
reason: 'Value clamped to maximum allowed'
|
||
};
|
||
}
|
||
|
||
// Calculate redistribution
|
||
const affectedSources = this.calculateRedistribution(sourceId, clampedValue, otherUnlockedSources);
|
||
|
||
return {
|
||
isValid: true,
|
||
actualValue: clampedValue,
|
||
affectedSources: affectedSources,
|
||
reason: 'Valid change'
|
||
};
|
||
}
|
||
|
||
calculateRedistribution(sourceId, newValue, otherUnlockedSources) {
|
||
const result = [{ id: sourceId, newPercentage: newValue }];
|
||
|
||
if (otherUnlockedSources.length === 0) {
|
||
return result;
|
||
}
|
||
|
||
// Calculate total locked percentage
|
||
const lockedSources = this.foodSources.filter(fs => fs.id !== sourceId && fs.isLocked);
|
||
const totalLocked = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
// Available percentage for other unlocked sources
|
||
const availableForOthers = 100 - newValue - totalLocked;
|
||
|
||
// Current total of other unlocked sources
|
||
const currentOtherTotal = otherUnlockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
if (currentOtherTotal === 0 || availableForOthers === 0) {
|
||
// Distribute equally among other unlocked sources
|
||
const equalShare = Math.floor(availableForOthers / otherUnlockedSources.length);
|
||
const remainder = availableForOthers - (equalShare * otherUnlockedSources.length);
|
||
|
||
otherUnlockedSources.forEach((fs, index) => {
|
||
const newPercentage = equalShare + (index < remainder ? 1 : 0);
|
||
result.push({ id: fs.id, newPercentage });
|
||
});
|
||
} else {
|
||
// Distribute proportionally
|
||
const scale = availableForOthers / currentOtherTotal;
|
||
let distributedTotal = 0;
|
||
|
||
otherUnlockedSources.forEach((fs, index) => {
|
||
let newPercentage;
|
||
if (index === otherUnlockedSources.length - 1) {
|
||
// Last item gets remainder to ensure exact total
|
||
newPercentage = availableForOthers - distributedTotal;
|
||
} else {
|
||
newPercentage = Math.round(fs.percentage * scale);
|
||
distributedTotal += newPercentage;
|
||
}
|
||
result.push({ id: fs.id, newPercentage });
|
||
});
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
applyValidatedChanges(validationResult) {
|
||
if (!validationResult.isValid) {
|
||
return false;
|
||
}
|
||
|
||
// Apply all percentage changes
|
||
validationResult.affectedSources.forEach(change => {
|
||
const source = this.foodSources.find(fs => fs.id === change.id);
|
||
if (source) {
|
||
source.percentage = change.newPercentage;
|
||
}
|
||
});
|
||
|
||
return true;
|
||
}
|
||
|
||
refreshAllPercentageUI() {
|
||
this.foodSources.forEach(fs => {
|
||
// Update all UI elements from single source of truth
|
||
const slider = document.getElementById(`percentage-slider-${fs.id}`);
|
||
const input = document.getElementById(`percentage-input-${fs.id}`);
|
||
const display = document.getElementById(`percentage-display-${fs.id}`);
|
||
|
||
if (slider) slider.value = fs.percentage;
|
||
if (input) input.value = fs.percentage;
|
||
if (display) display.textContent = `${fs.percentage}%`;
|
||
|
||
// Update constraints and disabled states
|
||
this.updateSliderConstraints(fs);
|
||
});
|
||
|
||
// Update food calculations
|
||
this.updateFoodCalculations();
|
||
}
|
||
|
||
updateSliderConstraints(foodSource) {
|
||
const slider = document.getElementById(`percentage-slider-${foodSource.id}`);
|
||
const input = document.getElementById(`percentage-input-${foodSource.id}`);
|
||
|
||
if (!slider || !input) return;
|
||
|
||
// Always keep 0-100 scale
|
||
slider.max = 100;
|
||
input.max = 100;
|
||
|
||
if (foodSource.isLocked) {
|
||
slider.disabled = true;
|
||
input.disabled = true;
|
||
} else {
|
||
// Calculate maximum allowed and store for validation
|
||
const maxAllowed = this.calculateMaxAllowed(foodSource.id);
|
||
slider.disabled = (maxAllowed <= 0);
|
||
input.disabled = (maxAllowed <= 0);
|
||
slider.dataset.maxAllowed = maxAllowed;
|
||
input.dataset.maxAllowed = maxAllowed;
|
||
}
|
||
}
|
||
|
||
calculateMaxAllowed(sourceId) {
|
||
const lockedSources = this.foodSources.filter(fs => fs.id !== sourceId && fs.isLocked);
|
||
const otherUnlockedSources = this.foodSources.filter(fs => fs.id !== sourceId && !fs.isLocked);
|
||
|
||
const totalLocked = lockedSources.reduce((sum, fs) => sum + fs.percentage, 0);
|
||
|
||
// If this is the only unlocked source, it must take up the remainder
|
||
if (otherUnlockedSources.length === 0) {
|
||
return 100 - totalLocked;
|
||
}
|
||
|
||
// Otherwise, maximum is 100 minus locked percentages
|
||
return Math.max(0, 100 - totalLocked);
|
||
}
|
||
|
||
updateFoodSourceNames() {
|
||
this.foodSources.forEach((fs, index) => {
|
||
// Only update if the name is still the default pattern
|
||
if (fs.name.match(/^Food Source \d+$/)) {
|
||
fs.name = `Food Source ${index + 1}`;
|
||
const titleElement = document.getElementById(`food-title-${fs.id}`);
|
||
if (titleElement) {
|
||
titleElement.value = fs.name;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
updateAddButton() {
|
||
const addBtn = document.getElementById('addFoodBtn');
|
||
|
||
if (addBtn) {
|
||
const remaining = this.maxFoodSources - this.foodSources.length;
|
||
const buttonText = addBtn.querySelector('span:last-child');
|
||
|
||
if (remaining <= 0) {
|
||
// Disable button and show max reached message
|
||
addBtn.disabled = true;
|
||
if (buttonText) {
|
||
buttonText.textContent = `Maximum ${this.maxFoodSources} sources reached`;
|
||
}
|
||
} else {
|
||
// Enable button with normal text
|
||
addBtn.disabled = false;
|
||
if (buttonText) {
|
||
buttonText.textContent = 'Add another food source';
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
updateRemoveButtons() {
|
||
// Show/hide remove buttons based on whether we have more than one source
|
||
const hasMultipleSources = this.foodSources.length > 1;
|
||
|
||
this.foodSources.forEach(fs => {
|
||
const removeBtn = document.getElementById(`remove-${fs.id}`);
|
||
if (removeBtn) {
|
||
removeBtn.style.display = hasMultipleSources ? 'block' : 'none';
|
||
}
|
||
});
|
||
}
|
||
|
||
renderFoodSource(foodSource) {
|
||
const container = document.getElementById('foodSources');
|
||
if (!container) return;
|
||
|
||
const cardHTML = `
|
||
<div class="dog-calculator-food-source-card" id="foodSource-${foodSource.id}">
|
||
<div class="dog-calculator-food-source-header">
|
||
<input type="text" class="dog-calculator-food-source-name-input" id="food-title-${foodSource.id}" value="${foodSource.name}" placeholder="Enter food name" maxlength="50" title="Click to edit food source name">
|
||
<button class="dog-calculator-remove-food-btn" id="remove-${foodSource.id}" type="button" title="Remove this food source" style="display: ${this.foodSources.length > 1 ? 'block' : 'none'}">×</button>
|
||
</div>
|
||
|
||
<div class="dog-calculator-input-group">
|
||
<div class="dog-calculator-form-group">
|
||
<label for="energy-${foodSource.id}">Energy Content:</label>
|
||
<input type="number" id="energy-${foodSource.id}" min="1" step="1" placeholder="Enter energy content" value="${foodSource.energy}">
|
||
</div>
|
||
<div class="dog-calculator-form-group">
|
||
<label for="energy-unit-${foodSource.id}">Unit:</label>
|
||
<select id="energy-unit-${foodSource.id}" class="dog-calculator-unit-select">
|
||
<option value="kcal100g" ${foodSource.energyUnit === 'kcal100g' ? 'selected' : ''}>kcal/100g</option>
|
||
<option value="kcalkg" ${foodSource.energyUnit === 'kcalkg' ? 'selected' : ''}>kcal/kg</option>
|
||
<option value="kcalcup" ${foodSource.energyUnit === 'kcalcup' ? 'selected' : ''}>kcal/cup</option>
|
||
<option value="kcalcan" ${foodSource.energyUnit === 'kcalcan' ? 'selected' : ''}>kcal/can</option>
|
||
</select>
|
||
</div>
|
||
</div>
|
||
<div id="energy-error-${foodSource.id}" class="dog-calculator-error dog-calculator-hidden">Please enter a valid energy content</div>
|
||
|
||
<div class="dog-calculator-percentage-group">
|
||
<label class="dog-calculator-percentage-label" for="percentage-slider-${foodSource.id}">
|
||
Percentage of Diet: <span id="percentage-display-${foodSource.id}">${foodSource.percentage}%</span>
|
||
<span class="dog-calculator-lock-icon unlocked" id="lock-${foodSource.id}" title="Lock this percentage">🔒</span>
|
||
</label>
|
||
<div class="dog-calculator-percentage-input-group">
|
||
<input type="range" id="percentage-slider-${foodSource.id}" class="dog-calculator-percentage-slider"
|
||
min="0" max="100" value="${foodSource.percentage}">
|
||
<input type="number" id="percentage-input-${foodSource.id}" class="dog-calculator-percentage-input"
|
||
min="0" max="100" value="${foodSource.percentage}">
|
||
</div>
|
||
</div>
|
||
</div>
|
||
`;
|
||
|
||
container.insertAdjacentHTML('beforeend', cardHTML);
|
||
|
||
// Bind events for the new food source
|
||
this.bindFoodSourceEvents(foodSource.id);
|
||
}
|
||
|
||
bindFoodSourceEvents(id) {
|
||
// Name input events
|
||
const nameInput = document.getElementById(`food-title-${id}`);
|
||
|
||
// Energy input events
|
||
const energyInput = document.getElementById(`energy-${id}`);
|
||
const energyUnitSelect = document.getElementById(`energy-unit-${id}`);
|
||
const percentageSlider = document.getElementById(`percentage-slider-${id}`);
|
||
const percentageInput = document.getElementById(`percentage-input-${id}`);
|
||
const removeBtn = document.getElementById(`remove-${id}`);
|
||
const lockBtn = document.getElementById(`lock-${id}`);
|
||
|
||
if (nameInput) {
|
||
nameInput.addEventListener('input', () => {
|
||
const newName = nameInput.value.trim() || `Food Source ${this.foodSources.findIndex(fs => fs.id === id) + 1}`;
|
||
this.updateFoodSourceData(id, 'name', newName);
|
||
this.updateFoodCalculations(); // This will refresh the food amount breakdown with new names
|
||
});
|
||
|
||
nameInput.addEventListener('blur', () => {
|
||
// If field is empty, restore default name
|
||
if (!nameInput.value.trim()) {
|
||
const defaultName = `Food Source ${this.foodSources.findIndex(fs => fs.id === id) + 1}`;
|
||
nameInput.value = defaultName;
|
||
this.updateFoodSourceData(id, 'name', defaultName);
|
||
this.updateFoodCalculations();
|
||
}
|
||
});
|
||
}
|
||
|
||
if (energyInput) {
|
||
energyInput.addEventListener('input', () => {
|
||
this.updateFoodSourceData(id, 'energy', energyInput.value);
|
||
// If kibble reference changed, recompute daily target
|
||
if (id === this.kibbleRefId) {
|
||
this.updateCalorieCalculations();
|
||
}
|
||
|
||
// Auto-select cups when entering energy for kcal/cup
|
||
const foodSource = this.foodSources.find(fs => fs.id === id);
|
||
if (foodSource && foodSource.energyUnit === 'kcalcup' && parseFloat(energyInput.value) > 0) {
|
||
// Cups display removed; default to grams
|
||
const unitSelect = document.getElementById('unit');
|
||
if (unitSelect) {
|
||
unitSelect.value = 'g';
|
||
unitSelect.setAttribute('value', 'g');
|
||
this.setActiveUnitButton('g');
|
||
}
|
||
}
|
||
this.updateFoodCalculations();
|
||
});
|
||
energyInput.addEventListener('blur', () => this.validateFoodSourceEnergy(id));
|
||
}
|
||
|
||
if (energyUnitSelect) {
|
||
energyUnitSelect.addEventListener('change', () => {
|
||
this.updateFoodSourceData(id, 'energyUnit', energyUnitSelect.value);
|
||
if (id === this.kibbleRefId) {
|
||
this.updateCalorieCalculations();
|
||
}
|
||
|
||
// Auto-select the most appropriate unit based on energy unit
|
||
const unitSelect = document.getElementById('unit');
|
||
const energyInput = document.getElementById(`energy-${id}`);
|
||
|
||
if (unitSelect) {
|
||
switch(energyUnitSelect.value) {
|
||
case 'kcalcup':
|
||
// Cups display not available; default to grams
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
this.updateFoodCalculations();
|
||
break;
|
||
case 'kcal100g':
|
||
// For kcal/100g, select grams
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
this.updateFoodCalculations();
|
||
break;
|
||
case 'kcalkg':
|
||
// For kcal/kg, also select grams (or could be kg)
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
this.updateFoodCalculations();
|
||
break;
|
||
case 'kcalcan':
|
||
// For kcal/can, use grams as default
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
this.updateFoodCalculations();
|
||
break;
|
||
}
|
||
} else {
|
||
// No unit select, just update calculations
|
||
this.updateFoodCalculations();
|
||
}
|
||
});
|
||
}
|
||
|
||
if (percentageSlider) {
|
||
percentageSlider.addEventListener('input', () => {
|
||
const requestedValue = parseInt(percentageSlider.value);
|
||
const result = this.validatePercentageChange(id, requestedValue);
|
||
|
||
if (result.isValid) {
|
||
this.applyValidatedChanges(result);
|
||
}
|
||
// Always refresh to ensure valid state
|
||
this.refreshAllPercentageUI();
|
||
});
|
||
}
|
||
|
||
if (percentageInput) {
|
||
percentageInput.addEventListener('change', () => {
|
||
const requestedValue = parseInt(percentageInput.value) || 0;
|
||
const result = this.validatePercentageChange(id, requestedValue);
|
||
|
||
if (result.isValid) {
|
||
this.applyValidatedChanges(result);
|
||
}
|
||
this.refreshAllPercentageUI();
|
||
});
|
||
}
|
||
|
||
if (removeBtn) {
|
||
removeBtn.addEventListener('click', () => this.removeFoodSource(id));
|
||
}
|
||
|
||
if (lockBtn) {
|
||
lockBtn.addEventListener('click', () => this.toggleLock(id));
|
||
}
|
||
}
|
||
|
||
toggleLock(id) {
|
||
const foodSource = this.foodSources.find(fs => fs.id === id);
|
||
if (!foodSource) return;
|
||
|
||
// Check if we're trying to lock the last unlocked source
|
||
const unlockedSources = this.foodSources.filter(fs => !fs.isLocked);
|
||
if (unlockedSources.length === 1 && unlockedSources[0].id === id) {
|
||
// Cannot lock the last unlocked source
|
||
alert('At least one food source must remain flexible for percentage adjustments.');
|
||
return;
|
||
}
|
||
|
||
// Toggle lock state
|
||
foodSource.isLocked = !foodSource.isLocked;
|
||
this.updateLockIcon(id);
|
||
this.updateLockStates();
|
||
this.refreshAllPercentageUI();
|
||
}
|
||
|
||
updateLockIcon(id) {
|
||
const foodSource = this.foodSources.find(fs => fs.id === id);
|
||
const lockIcon = document.getElementById(`lock-${id}`);
|
||
|
||
if (!lockIcon || !foodSource) return;
|
||
|
||
if (foodSource.isLocked) {
|
||
lockIcon.classList.remove('unlocked');
|
||
lockIcon.classList.add('locked');
|
||
lockIcon.title = 'Unlock this percentage';
|
||
} else {
|
||
lockIcon.classList.remove('locked');
|
||
lockIcon.classList.add('unlocked');
|
||
lockIcon.title = 'Lock this percentage';
|
||
}
|
||
}
|
||
|
||
updateLockStates() {
|
||
const unlockedSources = this.foodSources.filter(fs => !fs.isLocked);
|
||
|
||
// Update lock icon states - disable lock for last unlocked source
|
||
this.foodSources.forEach(fs => {
|
||
const lockIcon = document.getElementById(`lock-${fs.id}`);
|
||
if (lockIcon) {
|
||
if (!fs.isLocked && unlockedSources.length === 1) {
|
||
lockIcon.classList.add('disabled');
|
||
lockIcon.title = 'Cannot lock - at least one source must remain flexible';
|
||
} else {
|
||
lockIcon.classList.remove('disabled');
|
||
lockIcon.title = fs.isLocked ? 'Unlock this percentage' : 'Lock this percentage';
|
||
}
|
||
}
|
||
});
|
||
|
||
// Update percentage constraints based on lock states
|
||
this.refreshAllPercentageUI();
|
||
}
|
||
|
||
updateFoodSourceData(id, field, value) {
|
||
const foodSource = this.foodSources.find(fs => fs.id === id);
|
||
if (foodSource) {
|
||
foodSource[field] = value;
|
||
}
|
||
}
|
||
|
||
validateFoodSourceEnergy(id) {
|
||
const energyInput = document.getElementById(`energy-${id}`);
|
||
const energyUnitSelect = document.getElementById(`energy-unit-${id}`);
|
||
const errorElement = document.getElementById(`energy-error-${id}`);
|
||
|
||
if (!energyInput || !energyUnitSelect || !errorElement) return;
|
||
|
||
const energy = parseFloat(energyInput.value);
|
||
const unit = energyUnitSelect.value;
|
||
|
||
let minValue = 1;
|
||
switch (unit) {
|
||
case 'kcal100g': minValue = 1; break;
|
||
case 'kcalkg': minValue = 10; break;
|
||
case 'kcalcup': minValue = 50; break;
|
||
case 'kcalcan': minValue = 100; break;
|
||
}
|
||
|
||
if (!this.validateInput(energy, minValue)) {
|
||
errorElement.classList.remove('dog-calculator-hidden');
|
||
} else {
|
||
errorElement.classList.add('dog-calculator-hidden');
|
||
}
|
||
}
|
||
|
||
bindEvents() {
|
||
const weightInput = document.getElementById('weight');
|
||
const dogTypeSelect = document.getElementById('dogType');
|
||
const ageInput = document.getElementById('ageMonths');
|
||
const daysInput = document.getElementById('days');
|
||
const unitSelect = document.getElementById('unit');
|
||
const unitToggle = document.getElementById('unitToggle');
|
||
const addFoodBtn = document.getElementById('addFoodBtn');
|
||
|
||
if (weightInput) {
|
||
weightInput.addEventListener('input', () => this.updateCalorieCalculations());
|
||
weightInput.addEventListener('blur', () => this.validateWeight());
|
||
}
|
||
|
||
if (dogTypeSelect) dogTypeSelect.addEventListener('change', () => this.updateCalorieCalculations());
|
||
|
||
// Kayafied: age input drives energy target
|
||
if (ageInput) {
|
||
ageInput.addEventListener('input', () => this.updateCalorieCalculations());
|
||
ageInput.addEventListener('blur', () => this.updateCalorieCalculations());
|
||
}
|
||
|
||
if (daysInput) {
|
||
daysInput.addEventListener('input', () => {
|
||
this.updateDayLabel();
|
||
this.updateFoodCalculations();
|
||
});
|
||
daysInput.addEventListener('blur', () => this.validateDays());
|
||
}
|
||
|
||
if (unitSelect) unitSelect.addEventListener('change', () => this.updateFoodCalculations());
|
||
|
||
// Unit button event listeners
|
||
const unitButtons = document.querySelectorAll('.dog-calculator-unit-btn');
|
||
unitButtons.forEach(button => {
|
||
button.addEventListener('click', (e) => {
|
||
const selectedUnit = e.target.dataset.unit;
|
||
this.setActiveUnitButton(selectedUnit);
|
||
// Update hidden select to trigger existing logic
|
||
if (unitSelect) {
|
||
unitSelect.value = selectedUnit;
|
||
this.updateFoodCalculations();
|
||
}
|
||
});
|
||
});
|
||
|
||
if (unitToggle) unitToggle.addEventListener('change', () => this.toggleUnits());
|
||
|
||
if (addFoodBtn) addFoodBtn.addEventListener('click', () => this.addFoodSource());
|
||
|
||
// Feeding configuration event listeners
|
||
const showDaily = document.getElementById('showDaily');
|
||
const showPerMeal = document.getElementById('showPerMeal');
|
||
const mealsPerDayInput = document.getElementById('mealsPerDay');
|
||
const mealInputGroup = document.getElementById('mealInputGroup');
|
||
|
||
if (showDaily) {
|
||
showDaily.addEventListener('change', () => {
|
||
if (showDaily.checked) {
|
||
this.showPerMeal = false;
|
||
if (mealInputGroup) mealInputGroup.style.display = 'none';
|
||
this.updateDayLabel();
|
||
this.updateFoodCalculations();
|
||
}
|
||
});
|
||
}
|
||
|
||
if (showPerMeal) {
|
||
showPerMeal.addEventListener('change', () => {
|
||
if (showPerMeal.checked) {
|
||
this.showPerMeal = true;
|
||
if (mealInputGroup) mealInputGroup.style.display = 'inline-flex';
|
||
this.updateDayLabel();
|
||
this.updateFoodCalculations();
|
||
}
|
||
});
|
||
}
|
||
|
||
if (mealsPerDayInput) {
|
||
mealsPerDayInput.addEventListener('input', () => {
|
||
const meals = parseInt(mealsPerDayInput.value);
|
||
if (meals && meals >= 1 && meals <= 10) {
|
||
this.mealsPerDay = meals;
|
||
if (this.showPerMeal) {
|
||
this.updateDayLabel();
|
||
this.updateFoodCalculations();
|
||
}
|
||
}
|
||
});
|
||
|
||
mealsPerDayInput.addEventListener('blur', () => {
|
||
if (!mealsPerDayInput.value || parseInt(mealsPerDayInput.value) < 1) {
|
||
mealsPerDayInput.value = 2;
|
||
this.mealsPerDay = 2;
|
||
if (this.showPerMeal) {
|
||
this.updateDayLabel();
|
||
this.updateFoodCalculations();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
// Modal event listeners
|
||
const shareBtn = document.getElementById('shareBtn');
|
||
const shareModalClose = document.getElementById('shareModalClose');
|
||
|
||
if (shareBtn) shareBtn.addEventListener('click', () => this.showShareModal());
|
||
if (shareModalClose) shareModalClose.addEventListener('click', () => this.hideShareModal());
|
||
|
||
// Share buttons
|
||
const shareFacebook = document.getElementById('shareFacebook');
|
||
const shareTwitter = document.getElementById('shareTwitter');
|
||
const shareLinkedIn = document.getElementById('shareLinkedIn');
|
||
const shareEmail = document.getElementById('shareEmail');
|
||
const shareCopy = document.getElementById('shareCopy');
|
||
|
||
if (shareFacebook) shareFacebook.addEventListener('click', () => this.shareToFacebook());
|
||
if (shareTwitter) shareTwitter.addEventListener('click', () => this.shareToTwitter());
|
||
if (shareLinkedIn) shareLinkedIn.addEventListener('click', () => this.shareToLinkedIn());
|
||
if (shareEmail) shareEmail.addEventListener('click', () => this.shareViaEmail());
|
||
if (shareCopy) shareCopy.addEventListener('click', () => this.copyShareLink());
|
||
|
||
// Embed copy buttons removed (embedding disabled)
|
||
|
||
// Close modals on outside click
|
||
const shareModal = document.getElementById('shareModal');
|
||
|
||
if (shareModal) {
|
||
shareModal.addEventListener('click', (e) => {
|
||
if (e.target === shareModal) this.hideShareModal();
|
||
});
|
||
}
|
||
|
||
// Embed modal removed
|
||
}
|
||
|
||
toggleUnits() {
|
||
const toggle = document.getElementById('unitToggle');
|
||
this.isImperial = toggle.checked;
|
||
|
||
this.updateUnitLabels();
|
||
this.convertExistingValues();
|
||
this.updateCalorieCalculations();
|
||
}
|
||
|
||
updateUnitLabels() {
|
||
const metricLabel = document.getElementById('metricLabel');
|
||
const imperialLabel = document.getElementById('imperialLabel');
|
||
const weightLabel = document.getElementById('weightLabel');
|
||
const weightInput = document.getElementById('weight');
|
||
const unitSelect = document.getElementById('unit');
|
||
|
||
if (metricLabel && imperialLabel) {
|
||
metricLabel.classList.toggle('active', !this.isImperial);
|
||
imperialLabel.classList.toggle('active', this.isImperial);
|
||
}
|
||
|
||
// Kaya: restrict to metric g/kg only
|
||
if (unitSelect) {
|
||
unitSelect.innerHTML = '<option value="g">grams (g)</option>' +
|
||
'<option value="kg">kilograms (kg)</option>';
|
||
if (!unitSelect.value || (unitSelect.value !== 'g' && unitSelect.value !== 'kg')) {
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
}
|
||
}
|
||
}
|
||
|
||
convertExistingValues() {
|
||
const weightInput = document.getElementById('weight');
|
||
|
||
if (weightInput && weightInput.value) {
|
||
const currentWeight = parseFloat(weightInput.value);
|
||
if (!isNaN(currentWeight)) {
|
||
if (this.isImperial) {
|
||
weightInput.value = this.formatNumber(currentWeight * 2.20462, 1);
|
||
} else {
|
||
weightInput.value = this.formatNumber(currentWeight / 2.20462, 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
getWeightInKg() {
|
||
const weightInput = document.getElementById('weight');
|
||
if (!weightInput || !weightInput.value) return null;
|
||
|
||
const weight = parseFloat(weightInput.value);
|
||
if (isNaN(weight)) return null;
|
||
|
||
return this.isImperial ? weight / 2.20462 : weight;
|
||
}
|
||
|
||
|
||
calculateRER(weightKg) {
|
||
return 70 * Math.pow(weightKg, 0.75);
|
||
}
|
||
|
||
calculateMER(rer, factor) {
|
||
return rer * factor;
|
||
}
|
||
|
||
// Get the range multipliers for each life stage
|
||
getLifeStageRange(factor) {
|
||
// Define ranges based on the reference image
|
||
const ranges = {
|
||
'3.0': { min: 3.0, max: 3.0 }, // Puppy 0-4 months (no range)
|
||
'2.0': { min: 2.0, max: 2.0 }, // Puppy 4m-adult OR Working light (no range for puppies)
|
||
'1.2': { min: 1.2, max: 1.4 }, // Adult inactive/obese
|
||
'1.6': { min: 1.4, max: 1.6 }, // Adult neutered/spayed
|
||
'1.8': { min: 1.6, max: 1.8 }, // Adult intact
|
||
'1.0': { min: 1.0, max: 1.0 }, // Weight loss (fixed)
|
||
'1.7': { min: 1.2, max: 1.8 }, // Weight gain (wide range)
|
||
'5.0': { min: 5.0, max: 5.0 }, // Working heavy (upper bound)
|
||
'1.1': { min: 1.1, max: 1.1 } // Senior (no range)
|
||
};
|
||
|
||
const key = factor.toFixed(1);
|
||
return ranges[key] || { min: factor, max: factor };
|
||
}
|
||
|
||
validateInput(value, min = 0, isInteger = false) {
|
||
const num = parseFloat(value);
|
||
if (isNaN(num) || num < min) return false;
|
||
if (isInteger && !Number.isInteger(num)) return false;
|
||
return true;
|
||
}
|
||
|
||
showError(elementId, show = true) {
|
||
const errorElement = document.getElementById(elementId);
|
||
if (errorElement) {
|
||
if (show) {
|
||
errorElement.classList.remove('dog-calculator-hidden');
|
||
} else {
|
||
errorElement.classList.add('dog-calculator-hidden');
|
||
}
|
||
}
|
||
}
|
||
|
||
convertUnits(grams, unit, foodSource = null) {
|
||
switch (unit) {
|
||
case 'kg':
|
||
return grams / 1000;
|
||
case 'oz':
|
||
return grams / 28.3495;
|
||
case 'lb':
|
||
return grams / 453.592;
|
||
case 'cups':
|
||
// For cups, we need to convert from grams worth of calories to cups
|
||
if (foodSource && foodSource.energyUnit === 'kcalcup' && foodSource.energy) {
|
||
// Get calories per 100g for this food
|
||
const caloriesPerGram = this.getFoodSourceEnergyPer100g(foodSource) / 100;
|
||
// Calculate total calories represented by these grams
|
||
const totalCalories = grams * caloriesPerGram;
|
||
// Divide by calories per cup to get number of cups
|
||
const caloriesPerCup = parseFloat(foodSource.energy);
|
||
return totalCalories / caloriesPerCup;
|
||
}
|
||
return null; // Cannot convert to cups without kcal/cup
|
||
default:
|
||
return grams;
|
||
}
|
||
}
|
||
|
||
formatNumber(num, decimals = 0) {
|
||
if (decimals === 0) {
|
||
return Math.round(num).toString();
|
||
}
|
||
return num.toFixed(decimals).replace(/\.?0+$/, '');
|
||
}
|
||
|
||
validateWeight() {
|
||
const weightKg = this.getWeightInKg();
|
||
if (weightKg !== null && weightKg < 0.1) {
|
||
this.showError('weightError', true);
|
||
} else {
|
||
this.showError('weightError', false);
|
||
}
|
||
}
|
||
|
||
|
||
validateDays() {
|
||
const days = document.getElementById('days')?.value;
|
||
if (days && !this.validateInput(days, 1, true)) {
|
||
this.showError('daysError', true);
|
||
} else {
|
||
this.showError('daysError', false);
|
||
}
|
||
}
|
||
|
||
updateDayLabel() {
|
||
const days = document.getElementById('days')?.value;
|
||
const dayLabel = document.getElementById('dayLabel');
|
||
const mealNote = document.getElementById('mealNote');
|
||
if (dayLabel && days) {
|
||
const numDays = parseInt(days);
|
||
dayLabel.textContent = numDays === 1 ? 'day' : 'days';
|
||
}
|
||
if (mealNote) {
|
||
if (this.showPerMeal && days) {
|
||
const numDays = parseInt(days);
|
||
const totalMeals = numDays * this.mealsPerDay;
|
||
mealNote.textContent = ` (${totalMeals} meal${totalMeals === 1 ? '' : 's'} total)`;
|
||
mealNote.style.display = 'inline';
|
||
} else {
|
||
mealNote.style.display = 'none';
|
||
}
|
||
}
|
||
}
|
||
|
||
setActiveUnitButton(unit) {
|
||
const unitButtons = document.querySelectorAll('.dog-calculator-unit-btn');
|
||
unitButtons.forEach(button => {
|
||
button.classList.remove('active');
|
||
if (button.dataset.unit === unit) {
|
||
button.classList.add('active');
|
||
}
|
||
});
|
||
}
|
||
|
||
updateCalorieCalculations() {
|
||
// Kaya-specific: compute daily kcal target from age + kibble energy
|
||
const ageInput = document.getElementById('ageMonths');
|
||
const ageClampNote = document.getElementById('ageClampNote');
|
||
|
||
// Default: hide clamp note
|
||
if (ageClampNote) ageClampNote.classList.add('dog-calculator-hidden');
|
||
|
||
if (!ageInput || !ageInput.value) {
|
||
this.currentMER = 0;
|
||
this.currentMERMin = 0;
|
||
this.currentMERMax = 0;
|
||
return;
|
||
}
|
||
|
||
let age = parseFloat(ageInput.value);
|
||
if (isNaN(age)) {
|
||
this.currentMER = 0;
|
||
this.currentMERMin = 0;
|
||
this.currentMERMax = 0;
|
||
return;
|
||
}
|
||
|
||
// Clamp age to [2, 12]
|
||
if (age < 2) { age = 2; if (ageClampNote) ageClampNote.classList.remove('dog-calculator-hidden'); }
|
||
if (age > 12) { age = 12; if (ageClampNote) ageClampNote.classList.remove('dog-calculator-hidden'); }
|
||
|
||
// Bucket pills removed
|
||
|
||
// Calculate interpolated kibble grams/day for 30 kg at this age
|
||
const kibbleGrams = this.getKayaKibbleGramsForAge(age);
|
||
|
||
// Get kibble reference energy density in kcal/100g
|
||
let kibbleEnergyPer100g = null;
|
||
if (this.kibbleRefId) {
|
||
const kibbleRef = this.foodSources.find(fs => fs.id === this.kibbleRefId);
|
||
kibbleEnergyPer100g = kibbleRef ? this.getFoodSourceEnergyPer100g(kibbleRef) : null;
|
||
}
|
||
|
||
if (!kibbleEnergyPer100g || kibbleEnergyPer100g <= 0) {
|
||
// Cannot compute without kibble energy density
|
||
this.currentMER = 0;
|
||
this.currentMERMin = 0;
|
||
this.currentMERMax = 0;
|
||
return;
|
||
}
|
||
|
||
const kcalPerGram = kibbleEnergyPer100g / 100.0;
|
||
const dailyKcal = kibbleGrams * kcalPerGram;
|
||
this.currentMER = dailyKcal;
|
||
this.currentMERMin = dailyKcal;
|
||
this.currentMERMax = dailyKcal;
|
||
|
||
this.updateFoodCalculations();
|
||
}
|
||
|
||
// Kaya: monthly table with interpolation between months
|
||
getKayaKibbleGramsForAge(ageMonths) {
|
||
// Precomputed monthly values for 30 kg (g/day)
|
||
const table = {
|
||
2: 250,
|
||
3: 330,
|
||
4: 365,
|
||
5: 382,
|
||
6: 400,
|
||
7: 405,
|
||
8: 410,
|
||
9: 410,
|
||
10: 410,
|
||
11: 408,
|
||
12: 405
|
||
};
|
||
// Exact integer month
|
||
const lower = Math.floor(ageMonths);
|
||
const upper = Math.ceil(ageMonths);
|
||
if (lower === upper) return table[lower] || 0;
|
||
// Linear interpolation between bounds
|
||
const lowerVal = table[lower] || 0;
|
||
const upperVal = table[upper] || 0;
|
||
const t = (ageMonths - lower) / (upper - lower);
|
||
return lowerVal + (upperVal - lowerVal) * t;
|
||
}
|
||
|
||
|
||
|
||
updateCupsButtonState() {
|
||
const cupsButton = document.getElementById('cupsButton');
|
||
if (!cupsButton) return;
|
||
|
||
// Check if any food source has kcal/cup selected
|
||
const hasKcalCup = this.foodSources.some(fs =>
|
||
fs.energyUnit === 'kcalcup' && fs.energy && parseFloat(fs.energy) > 0
|
||
);
|
||
|
||
if (hasKcalCup) {
|
||
cupsButton.disabled = false;
|
||
cupsButton.title = 'Show amounts in cups';
|
||
} else {
|
||
cupsButton.disabled = true;
|
||
cupsButton.title = 'Available when using kcal/cup measurement';
|
||
|
||
// If cups was selected, switch back to grams
|
||
const unitSelect = document.getElementById('unit');
|
||
if (unitSelect && unitSelect.value === 'cups') {
|
||
unitSelect.value = 'g';
|
||
this.setActiveUnitButton('g');
|
||
}
|
||
}
|
||
}
|
||
|
||
updateFoodCalculations() {
|
||
if (this.currentMER === 0) return;
|
||
|
||
// Check if we have a range
|
||
const hasRange = this.currentMERMin !== this.currentMERMax;
|
||
|
||
const daysInput = document.getElementById('days');
|
||
const unitSelect = document.getElementById('unit');
|
||
const dailyFoodResults = document.getElementById('dailyFoodResults');
|
||
const dailyFoodValue = document.getElementById('dailyFoodValue');
|
||
const foodAmountsSection = document.getElementById('foodAmountsSection');
|
||
const foodAmountsList = document.getElementById('foodAmountsList');
|
||
const totalAmountDisplay = document.getElementById('totalAmountDisplay');
|
||
const foodBreakdownResults = document.getElementById('foodBreakdownResults');
|
||
const foodBreakdownList = document.getElementById('foodBreakdownList');
|
||
const feedingConfig = document.getElementById('feedingConfig');
|
||
|
||
// Update cups button state
|
||
this.updateCupsButtonState();
|
||
|
||
if (!daysInput || !unitSelect || !dailyFoodResults || !dailyFoodValue || !foodAmountsSection) {
|
||
return;
|
||
}
|
||
|
||
const days = daysInput.value;
|
||
let unit = unitSelect.value;
|
||
|
||
// Failsafe: if unit is empty string but cups button is active, use 'cups'
|
||
if (!unit || unit === '') {
|
||
const activeButton = document.querySelector('.dog-calculator-unit-btn.active');
|
||
if (activeButton) {
|
||
unit = activeButton.dataset.unit || 'g';
|
||
} else {
|
||
unit = 'g'; // Default fallback
|
||
}
|
||
}
|
||
|
||
const unitLabel = unit === 'g' ? 'g' : unit === 'kg' ? 'kg' : unit === 'oz' ? 'oz' : unit === 'lb' ? 'lb' : 'cups';
|
||
const decimals = unit === 'g' ? 0 : unit === 'kg' ? 2 : unit === 'cups' ? 1 : 1;
|
||
|
||
// Debug: log what unit is being used
|
||
console.log('UpdateFoodCalculations - unit:', unit, 'unitLabel:', unitLabel);
|
||
|
||
// Determine frequency suffix for display
|
||
const frequencySuffix = this.showPerMeal ? '/meal' : '/day';
|
||
|
||
// Clear all food source errors first
|
||
this.foodSources.forEach(fs => {
|
||
this.showError(`energy-error-${fs.id}`, false);
|
||
});
|
||
this.showError('daysError', false);
|
||
|
||
// Validate days input
|
||
if (!days || !this.validateInput(days, 1, true)) {
|
||
if (days) this.showError('daysError', true);
|
||
foodAmountsSection.style.display = 'none';
|
||
dailyFoodResults.style.display = 'none';
|
||
if (foodBreakdownResults) foodBreakdownResults.style.display = 'none';
|
||
if (feedingConfig) feedingConfig.style.display = 'none';
|
||
|
||
// Hide unit buttons when validation fails
|
||
const unitButtons = document.getElementById('unitButtons');
|
||
if (unitButtons) unitButtons.style.display = 'none';
|
||
return;
|
||
}
|
||
|
||
const numDays = parseInt(days);
|
||
|
||
// Calculate per-food breakdown
|
||
const foodBreakdowns = [];
|
||
let totalDailyGrams = 0;
|
||
let hasValidFoods = false;
|
||
|
||
this.foodSources.forEach(fs => {
|
||
const energyPer100g = this.getFoodSourceEnergyPer100g(fs);
|
||
|
||
if (energyPer100g && energyPer100g > 0.1 && fs.percentage > 0) {
|
||
const dailyCaloriesForThisFood = (this.currentMER * fs.percentage) / 100;
|
||
// Calculate range values if applicable
|
||
const dailyCaloriesMin = hasRange ? (this.currentMERMin * fs.percentage) / 100 : dailyCaloriesForThisFood;
|
||
const dailyCaloriesMax = hasRange ? (this.currentMERMax * fs.percentage) / 100 : dailyCaloriesForThisFood;
|
||
|
||
let dailyGramsForThisFood;
|
||
let dailyGramsMin, dailyGramsMax;
|
||
let dailyCupsForThisFood = null;
|
||
let dailyCupsMin, dailyCupsMax;
|
||
|
||
// For kcal/cup, calculate cups directly from calories
|
||
if (fs.energyUnit === 'kcalcup' && fs.energy) {
|
||
const caloriesPerCup = parseFloat(fs.energy);
|
||
dailyCupsForThisFood = dailyCaloriesForThisFood / caloriesPerCup;
|
||
dailyCupsMin = dailyCaloriesMin / caloriesPerCup;
|
||
dailyCupsMax = dailyCaloriesMax / caloriesPerCup;
|
||
// We still need grams for total calculation, use approximation
|
||
dailyGramsForThisFood = (dailyCaloriesForThisFood / energyPer100g) * 100;
|
||
dailyGramsMin = (dailyCaloriesMin / energyPer100g) * 100;
|
||
dailyGramsMax = (dailyCaloriesMax / energyPer100g) * 100;
|
||
} else {
|
||
// For other units, calculate grams normally
|
||
dailyGramsForThisFood = (dailyCaloriesForThisFood / energyPer100g) * 100;
|
||
dailyGramsMin = (dailyCaloriesMin / energyPer100g) * 100;
|
||
dailyGramsMax = (dailyCaloriesMax / energyPer100g) * 100;
|
||
}
|
||
|
||
// Calculate per-meal amounts if needed
|
||
const displayGrams = this.showPerMeal ? dailyGramsForThisFood / this.mealsPerDay : dailyGramsForThisFood;
|
||
const displayGramsMin = this.showPerMeal ? dailyGramsMin / this.mealsPerDay : dailyGramsMin;
|
||
const displayGramsMax = this.showPerMeal ? dailyGramsMax / this.mealsPerDay : dailyGramsMax;
|
||
|
||
const displayCups = dailyCupsForThisFood !== null ?
|
||
(this.showPerMeal ? dailyCupsForThisFood / this.mealsPerDay : dailyCupsForThisFood) : null;
|
||
const displayCupsMin = dailyCupsMin !== undefined ?
|
||
(this.showPerMeal ? dailyCupsMin / this.mealsPerDay : dailyCupsMin) : null;
|
||
const displayCupsMax = dailyCupsMax !== undefined ?
|
||
(this.showPerMeal ? dailyCupsMax / this.mealsPerDay : dailyCupsMax) : null;
|
||
|
||
const displayCalories = this.showPerMeal ? dailyCaloriesForThisFood / this.mealsPerDay : dailyCaloriesForThisFood;
|
||
const displayCaloriesMin = this.showPerMeal ? dailyCaloriesMin / this.mealsPerDay : dailyCaloriesMin;
|
||
const displayCaloriesMax = this.showPerMeal ? dailyCaloriesMax / this.mealsPerDay : dailyCaloriesMax;
|
||
|
||
foodBreakdowns.push({
|
||
name: fs.name,
|
||
percentage: fs.percentage,
|
||
dailyGrams: dailyGramsForThisFood,
|
||
dailyGramsMin: dailyGramsMin,
|
||
dailyGramsMax: dailyGramsMax,
|
||
displayGrams: displayGrams,
|
||
displayGramsMin: displayGramsMin,
|
||
displayGramsMax: displayGramsMax,
|
||
dailyCups: dailyCupsForThisFood,
|
||
dailyCupsMin: dailyCupsMin,
|
||
dailyCupsMax: dailyCupsMax,
|
||
displayCups: displayCups,
|
||
displayCupsMin: displayCupsMin,
|
||
displayCupsMax: displayCupsMax,
|
||
calories: dailyCaloriesForThisFood,
|
||
displayCalories: displayCalories,
|
||
displayCaloriesMin: displayCaloriesMin,
|
||
displayCaloriesMax: displayCaloriesMax,
|
||
isLocked: fs.isLocked,
|
||
hasEnergyContent: true,
|
||
hasRange: hasRange,
|
||
foodSource: fs // Store reference for cups conversion
|
||
});
|
||
|
||
totalDailyGrams += dailyGramsForThisFood;
|
||
hasValidFoods = true;
|
||
} else if (fs.percentage > 0) {
|
||
// Include food sources without energy content but show them as needing energy content
|
||
foodBreakdowns.push({
|
||
name: fs.name,
|
||
percentage: fs.percentage,
|
||
dailyGrams: 0,
|
||
displayGrams: 0,
|
||
dailyCups: null,
|
||
displayCups: null,
|
||
calories: 0,
|
||
displayCalories: 0,
|
||
isLocked: fs.isLocked,
|
||
hasEnergyContent: false,
|
||
foodSource: fs // Store reference for cups conversion
|
||
});
|
||
}
|
||
});
|
||
|
||
if (!hasValidFoods) {
|
||
// Show errors for invalid food sources
|
||
this.foodSources.forEach(fs => {
|
||
const energyInput = document.getElementById(`energy-${fs.id}`);
|
||
if (energyInput && energyInput.value && (!this.getFoodSourceEnergyPer100g(fs) || this.getFoodSourceEnergyPer100g(fs) <= 0.1)) {
|
||
this.showError(`energy-error-${fs.id}`, true);
|
||
}
|
||
});
|
||
|
||
dailyFoodResults.style.display = 'none';
|
||
if (foodBreakdownResults) foodBreakdownResults.style.display = 'none';
|
||
if (feedingConfig) feedingConfig.style.display = 'none';
|
||
|
||
// Hide unit buttons when no valid foods
|
||
const unitButtons = document.getElementById('unitButtons');
|
||
if (unitButtons) unitButtons.style.display = 'none';
|
||
|
||
// If we have any food sources without energy content, still show the breakdown section
|
||
if (foodBreakdowns.length > 0) {
|
||
// Show food amounts section with warnings for missing energy content
|
||
const unitLabel = unit === 'g' ? 'g' : unit === 'kg' ? 'kg' : unit === 'oz' ? 'oz' : 'lb';
|
||
|
||
const foodAmountsHTML = foodBreakdowns.map(breakdown => {
|
||
const lockIndicator = breakdown.isLocked ? '<span class="dog-calculator-lock-indicator">🔒</span>' : '';
|
||
|
||
return `
|
||
<div class="dog-calculator-food-amount-item">
|
||
<div class="dog-calculator-food-amount-label">
|
||
<span>${breakdown.name}</span>
|
||
<span class="dog-calculator-food-percentage">${breakdown.percentage}%</span>
|
||
${lockIndicator}
|
||
</div>
|
||
<div class="dog-calculator-food-amount-value dog-calculator-warning" title="Enter energy content to calculate amount">
|
||
⚠️
|
||
</div>
|
||
</div>
|
||
`;
|
||
}).join('');
|
||
|
||
if (foodAmountsList) {
|
||
foodAmountsList.innerHTML = foodAmountsHTML;
|
||
}
|
||
|
||
if (totalAmountDisplay) {
|
||
totalAmountDisplay.textContent = "Enter energy content for all foods";
|
||
}
|
||
|
||
foodAmountsSection.style.display = 'block';
|
||
this.sendHeightToParent();
|
||
} else {
|
||
foodAmountsSection.style.display = 'none';
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Update daily food results (total) - will be updated with proper units later
|
||
dailyFoodResults.style.display = 'block';
|
||
|
||
// Show feeding configuration when we have valid foods
|
||
if (feedingConfig) {
|
||
feedingConfig.style.display = 'block';
|
||
|
||
// Ensure "Per day" is checked when feeding config becomes visible
|
||
const showDaily = document.getElementById('showDaily');
|
||
if (showDaily && !showDaily.checked && !document.getElementById('showPerMeal').checked) {
|
||
showDaily.checked = true;
|
||
}
|
||
}
|
||
|
||
// Show unit buttons when daily results are shown
|
||
const unitButtons = document.getElementById('unitButtons');
|
||
if (unitButtons) unitButtons.style.display = 'flex';
|
||
|
||
// Update per-food breakdown
|
||
if (foodBreakdownList && foodBreakdowns.length > 1) {
|
||
const breakdownHTML = foodBreakdowns.map(breakdown => {
|
||
let valueContent;
|
||
if (breakdown.hasEnergyContent) {
|
||
if (unit === 'cups') {
|
||
// For cups, use the pre-calculated cups value if available
|
||
if (breakdown.displayCups !== null) {
|
||
if (breakdown.hasRange && breakdown.displayCupsMin !== breakdown.displayCupsMax) {
|
||
valueContent = `${this.formatNumber(breakdown.displayCupsMin, decimals)}-${this.formatNumber(breakdown.displayCupsMax, decimals)} ${unitLabel}${frequencySuffix}`;
|
||
} else {
|
||
valueContent = `${this.formatNumber(breakdown.displayCups, decimals)} ${unitLabel}${frequencySuffix}`;
|
||
}
|
||
} else {
|
||
valueContent = `<span class="dog-calculator-warning" title="Cups only available for foods with kcal/cup measurement">N/A</span>`;
|
||
}
|
||
} else {
|
||
// For other units (g, kg, oz, lb)
|
||
if (breakdown.hasRange && breakdown.displayGramsMin !== breakdown.displayGramsMax) {
|
||
const minConverted = this.convertUnits(breakdown.displayGramsMin, unit);
|
||
const maxConverted = this.convertUnits(breakdown.displayGramsMax, unit);
|
||
valueContent = `${this.formatNumber(minConverted, decimals)}-${this.formatNumber(maxConverted, decimals)} ${unitLabel}${frequencySuffix}`;
|
||
} else {
|
||
valueContent = `${this.formatNumber(this.convertUnits(breakdown.displayGrams, unit), decimals)} ${unitLabel}${frequencySuffix}`;
|
||
}
|
||
}
|
||
} else {
|
||
valueContent = `<span class="dog-calculator-warning" title="Enter energy content to calculate amount">⚠️</span>`;
|
||
}
|
||
|
||
return `
|
||
<div class="dog-calculator-food-result-item">
|
||
<span class="dog-calculator-food-result-label">${breakdown.name} (${breakdown.percentage}%${breakdown.isLocked ? ' - locked' : ''}):</span>
|
||
<span class="dog-calculator-food-result-value">${valueContent}</span>
|
||
</div>
|
||
`;
|
||
}).join('');
|
||
|
||
foodBreakdownList.innerHTML = breakdownHTML;
|
||
if (foodBreakdownResults) foodBreakdownResults.style.display = 'block';
|
||
} else {
|
||
if (foodBreakdownResults) foodBreakdownResults.style.display = 'none';
|
||
}
|
||
|
||
// Generate individual food amount breakdown
|
||
|
||
// Update daily food value with correct units
|
||
const displayTotal = this.showPerMeal ? totalDailyGrams / this.mealsPerDay : totalDailyGrams;
|
||
let convertedTotal;
|
||
let totalDisplayText;
|
||
|
||
if (unit === 'cups') {
|
||
console.log('Unit is cups, checking validity...');
|
||
// For cups, we can only show total if all foods with percentage > 0 have kcal/cup
|
||
const validForCups = foodBreakdowns.filter(b => b.percentage > 0)
|
||
.every(b => b.displayCups !== null && b.displayCups !== undefined);
|
||
|
||
console.log('Valid for cups?', validForCups, 'Breakdowns:', foodBreakdowns);
|
||
|
||
if (validForCups) {
|
||
// Calculate total cups using pre-calculated values
|
||
let totalCups = 0;
|
||
let totalCupsMin = 0;
|
||
let totalCupsMax = 0;
|
||
foodBreakdowns.forEach(breakdown => {
|
||
if (breakdown.percentage > 0 && breakdown.displayCups !== null) {
|
||
totalCups += breakdown.displayCups;
|
||
if (breakdown.hasRange) {
|
||
totalCupsMin += breakdown.displayCupsMin || breakdown.displayCups;
|
||
totalCupsMax += breakdown.displayCupsMax || breakdown.displayCups;
|
||
} else {
|
||
totalCupsMin += breakdown.displayCups;
|
||
totalCupsMax += breakdown.displayCups;
|
||
}
|
||
}
|
||
});
|
||
|
||
if (hasRange && totalCupsMin !== totalCupsMax) {
|
||
totalDisplayText = `${this.formatNumber(totalCupsMin, decimals)}-${this.formatNumber(totalCupsMax, decimals)} ${unitLabel}${frequencySuffix}`;
|
||
} else {
|
||
totalDisplayText = this.formatNumber(totalCups, decimals) + ` ${unitLabel}${frequencySuffix}`;
|
||
}
|
||
} else {
|
||
totalDisplayText = 'Mixed units - see breakdown';
|
||
}
|
||
} else {
|
||
// Calculate totals for ranges
|
||
if (hasRange) {
|
||
let totalGramsMin = 0;
|
||
let totalGramsMax = 0;
|
||
foodBreakdowns.forEach(breakdown => {
|
||
if (breakdown.percentage > 0 && breakdown.hasEnergyContent) {
|
||
totalGramsMin += breakdown.displayGramsMin || breakdown.displayGrams;
|
||
totalGramsMax += breakdown.displayGramsMax || breakdown.displayGrams;
|
||
}
|
||
});
|
||
|
||
const convertedMin = this.convertUnits(totalGramsMin, unit);
|
||
const convertedMax = this.convertUnits(totalGramsMax, unit);
|
||
|
||
if (totalGramsMin !== totalGramsMax) {
|
||
totalDisplayText = `${this.formatNumber(convertedMin, decimals)}-${this.formatNumber(convertedMax, decimals)} ${unitLabel}${frequencySuffix}`;
|
||
} else {
|
||
totalDisplayText = this.formatNumber(convertedMin, decimals) + ` ${unitLabel}${frequencySuffix}`;
|
||
}
|
||
} else {
|
||
convertedTotal = this.convertUnits(displayTotal, unit);
|
||
totalDisplayText = this.formatNumber(convertedTotal, decimals) + ` ${unitLabel}${frequencySuffix}`;
|
||
}
|
||
}
|
||
|
||
dailyFoodValue.textContent = totalDisplayText;
|
||
|
||
// Build HTML for individual food amounts
|
||
const foodAmountsHTML = foodBreakdowns.map(breakdown => {
|
||
const lockIndicator = breakdown.isLocked ? '<span class="dog-calculator-lock-indicator">🔒</span>' : '';
|
||
|
||
if (!breakdown.hasEnergyContent) {
|
||
// Show warning for food sources without energy content
|
||
return `
|
||
<div class="dog-calculator-food-amount-item">
|
||
<div class="dog-calculator-food-amount-label">
|
||
<span>${breakdown.name}</span>
|
||
<span class="dog-calculator-food-percentage">${breakdown.percentage}%</span>
|
||
${lockIndicator}
|
||
</div>
|
||
<div class="dog-calculator-food-amount-value dog-calculator-warning" title="Enter energy content to calculate amount">
|
||
⚠️
|
||
</div>
|
||
</div>
|
||
`;
|
||
} else {
|
||
// For multi-day calculations: show total amount for all days
|
||
let amountDisplay;
|
||
if (unit === 'cups') {
|
||
// For cups, use pre-calculated cups value
|
||
if (breakdown.dailyCups !== null) {
|
||
const totalCupsForDays = breakdown.dailyCups * numDays;
|
||
amountDisplay = `${this.formatNumber(totalCupsForDays, decimals)} ${unitLabel}`;
|
||
} else {
|
||
amountDisplay = `<span class="dog-calculator-warning" title="Cups only available for foods with kcal/cup measurement">N/A</span>`;
|
||
}
|
||
} else {
|
||
// For other units, calculate from grams
|
||
const totalGramsForDays = this.showPerMeal
|
||
? (breakdown.dailyGrams / this.mealsPerDay) * numDays * this.mealsPerDay
|
||
: breakdown.dailyGrams * numDays;
|
||
const convertedAmount = this.convertUnits(totalGramsForDays, unit);
|
||
amountDisplay = `${this.formatNumber(convertedAmount, decimals)} ${unitLabel}`;
|
||
}
|
||
|
||
return `
|
||
<div class="dog-calculator-food-amount-item">
|
||
<div class="dog-calculator-food-amount-label">
|
||
<span>${breakdown.name}</span>
|
||
<span class="dog-calculator-food-percentage">${breakdown.percentage}%</span>
|
||
${lockIndicator}
|
||
</div>
|
||
<div class="dog-calculator-food-amount-value">
|
||
${amountDisplay}
|
||
</div>
|
||
</div>
|
||
`;
|
||
}
|
||
}).join('');
|
||
|
||
// Calculate and display total
|
||
const totalFoodGrams = totalDailyGrams * numDays;
|
||
|
||
// Update the display
|
||
if (foodAmountsList) {
|
||
foodAmountsList.innerHTML = foodAmountsHTML;
|
||
}
|
||
|
||
if (totalAmountDisplay) {
|
||
if (unit === 'cups') {
|
||
// For cups total, check if all foods can be converted
|
||
const validForCups = foodBreakdowns.filter(b => b.percentage > 0)
|
||
.every(b => b.dailyCups !== null && b.dailyCups !== undefined);
|
||
|
||
if (validForCups) {
|
||
// Calculate total cups using pre-calculated values
|
||
let totalCups = 0;
|
||
foodBreakdowns.forEach(breakdown => {
|
||
if (breakdown.percentage > 0 && breakdown.dailyCups !== null) {
|
||
totalCups += breakdown.dailyCups * numDays;
|
||
}
|
||
});
|
||
totalAmountDisplay.textContent = `${this.formatNumber(totalCups, decimals)} ${unitLabel}`;
|
||
} else {
|
||
totalAmountDisplay.textContent = 'Mixed units - see individual amounts';
|
||
}
|
||
} else {
|
||
const totalConverted = this.convertUnits(totalFoodGrams, unit);
|
||
totalAmountDisplay.textContent = `${this.formatNumber(totalConverted, decimals)} ${unitLabel}`;
|
||
}
|
||
}
|
||
|
||
foodAmountsSection.style.display = 'block';
|
||
this.sendHeightToParent();
|
||
}
|
||
|
||
getFoodSourceEnergyPer100g(foodSource) {
|
||
if (!foodSource.energy || !foodSource.energyUnit) return null;
|
||
|
||
const energy = parseFloat(foodSource.energy);
|
||
if (isNaN(energy)) return null;
|
||
|
||
const unit = foodSource.energyUnit;
|
||
|
||
// Convert all units to kcal/100g for internal calculations
|
||
switch (unit) {
|
||
case 'kcal100g':
|
||
return energy;
|
||
case 'kcalkg':
|
||
return energy / 10; // 1 kg = 10 × 100g
|
||
case 'kcalcup':
|
||
return energy / 1.2; // Assume 1 cup ≈ 120g for dry dog food
|
||
case 'kcalcan':
|
||
return energy / 4.5; // Assume 1 can ≈ 450g for wet dog food
|
||
default:
|
||
return energy;
|
||
}
|
||
}
|
||
|
||
// Iframe auto-resize for allowed embeddings
|
||
setupIframeResize() {
|
||
// Only when embedded in an iframe
|
||
if (window.top === window.self) return;
|
||
|
||
// Initial send once UI is ready
|
||
setTimeout(() => this.sendHeightToParent(), 50);
|
||
|
||
// Monitor for content/attribute changes
|
||
const observer = new MutationObserver(() => {
|
||
clearTimeout(this._resizeTimer);
|
||
this._resizeTimer = setTimeout(() => this.sendHeightToParent(), 100);
|
||
});
|
||
|
||
observer.observe(document.body, {
|
||
childList: true,
|
||
subtree: true,
|
||
attributes: true
|
||
});
|
||
|
||
// On viewport resize
|
||
window.addEventListener('resize', () => this.sendHeightToParent());
|
||
}
|
||
|
||
sendHeightToParent() {
|
||
if (!(window.parent && window.parent !== window)) return;
|
||
const container = document.getElementById('dogCalculator');
|
||
// Prefer visual height including transform scaling
|
||
let height = 0;
|
||
if (container) {
|
||
const rect = container.getBoundingClientRect();
|
||
height = Math.ceil(rect.height);
|
||
} else {
|
||
height = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
|
||
}
|
||
window.parent.postMessage({
|
||
type: 'dogCalculatorResize',
|
||
height: height
|
||
}, '*');
|
||
}
|
||
|
||
// Modal functionality
|
||
showShareModal() {
|
||
const modal = document.getElementById('shareModal');
|
||
const shareUrl = document.getElementById('shareUrl');
|
||
if (modal && shareUrl) {
|
||
shareUrl.value = window.location.href;
|
||
// Use flex so content is centered within modal viewport
|
||
modal.style.display = 'flex';
|
||
// Sync modal scroll position with current page scroll so content is visible
|
||
try { modal.scrollTop = window.scrollY || document.documentElement.scrollTop || 0; } catch (e) {}
|
||
// Ensure the modal is visible even when the page is scrolled
|
||
// by recalculating parent iframe height (defensive)
|
||
this.sendHeightToParent();
|
||
}
|
||
}
|
||
|
||
hideShareModal() {
|
||
const modal = document.getElementById('shareModal');
|
||
if (modal) modal.style.display = 'none';
|
||
this.sendHeightToParent();
|
||
}
|
||
|
||
// Embed modal removed (embedding disabled)
|
||
|
||
// Embed modal removed (embedding disabled)
|
||
|
||
shareToFacebook() {
|
||
const url = encodeURIComponent(window.location.href);
|
||
window.open('https://www.facebook.com/sharer/sharer.php?u=' + url, '_blank', 'width=600,height=400');
|
||
}
|
||
|
||
shareToTwitter() {
|
||
const url = encodeURIComponent(window.location.href);
|
||
const text = encodeURIComponent('Check out this useful dog calorie calculator!');
|
||
window.open('https://twitter.com/intent/tweet?url=' + url + '&text=' + text, '_blank', 'width=600,height=400');
|
||
}
|
||
|
||
shareToLinkedIn() {
|
||
const url = encodeURIComponent(window.location.href);
|
||
window.open('https://www.linkedin.com/sharing/share-offsite/?url=' + url, '_blank', 'width=600,height=400');
|
||
}
|
||
|
||
shareViaEmail() {
|
||
const subject = encodeURIComponent('Dog Calorie Calculator');
|
||
const body = encodeURIComponent('Check out this useful dog calorie calculator: ' + window.location.href);
|
||
window.location.href = 'mailto:?subject=' + subject + '&body=' + body;
|
||
}
|
||
|
||
async copyShareLink() {
|
||
const shareUrl = document.getElementById('shareUrl');
|
||
const copyBtn = document.getElementById('shareCopy');
|
||
|
||
if (shareUrl && copyBtn) {
|
||
try {
|
||
await navigator.clipboard.writeText(shareUrl.value);
|
||
const originalText = copyBtn.textContent;
|
||
copyBtn.textContent = 'Copied!';
|
||
copyBtn.classList.add('copied');
|
||
|
||
setTimeout(() => {
|
||
copyBtn.textContent = originalText;
|
||
copyBtn.classList.remove('copied');
|
||
}, 2000);
|
||
} catch (err) {
|
||
// Fallback for older browsers
|
||
shareUrl.select();
|
||
document.execCommand('copy');
|
||
}
|
||
}
|
||
}
|
||
|
||
// Embed code copy removed (embedding disabled)
|
||
}
|
||
|
||
// Initialize calculator when DOM is ready
|
||
document.addEventListener('DOMContentLoaded', function() {
|
||
// Allow embedding only from approved parent hosts
|
||
if (window.top !== window.self) {
|
||
const allowedHosts = ['caninenutritionandwellness.com', 'www.caninenutritionandwellness.com'];
|
||
let parentAllowed = false;
|
||
|
||
// Prefer document.referrer when available
|
||
try {
|
||
if (document.referrer) {
|
||
const r = new URL(document.referrer);
|
||
parentAllowed = allowedHosts.includes(r.hostname);
|
||
}
|
||
} catch (e) {}
|
||
|
||
// Fallback: Chrome's ancestorOrigins (may be empty or absent)
|
||
if (!parentAllowed && window.location.ancestorOrigins && window.location.ancestorOrigins.length) {
|
||
parentAllowed = Array.from(window.location.ancestorOrigins).some((originStr) => {
|
||
try {
|
||
const o = new URL(originStr);
|
||
return allowedHosts.includes(o.hostname);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
});
|
||
}
|
||
|
||
if (!parentAllowed) {
|
||
document.body.innerHTML = '<div style="max-width:720px;margin:40px auto;padding:16px;border:1px solid #ddd;border-radius:8px;font-family:system-ui, -apple-system, Segoe UI, Roboto, sans-serif;color:#333;line-height:1.5;text-align:center;">Embedding of this calculator is only allowed on caninenutritionandwellness.com.</div>';
|
||
return;
|
||
}
|
||
}
|
||
new DogCalorieCalculator();
|
||
});
|