yummy-guide-generic-administrate 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f8a49b6cf64da8e522b0290770f402b7f387ba989d5e38ff0d17232b8a7ff2
-  data.tar.gz: '0648859c41c97f9bf5d6a5bef998fca7e8685a2a5b5d617bfbd1830d75d08fa9'
+  metadata.gz: d74616803937316aa5cb1017b29b59dd95d9853caf6b3f3dae65500265d18312
+  data.tar.gz: ff39212a171b9238896ccb7c8b5e6d4980ca655cfb110dde961434cbf558175c
 SHA512:
-  metadata.gz: 8e7752a04124f92bd2abdbb7d6f5e16284c593ff33166cd9429a202146ea0de5ca35e812c80bf69bb96eb1b1179daec5584ba66fa0c55fd9bc8921c78a072aef
-  data.tar.gz: 6d109d78f58cc76f4d125a6027aa28f4d048c0c3233b97b0b5c244edab96757f5c20c078461ca5975b6cf3cc3af5a32030bdd87563de9d38aa11167d31d57060
+  metadata.gz: 92b1684a3992f57bd1fe73ba84bc6f162761c9264843ff31cb769d9c4d87f6f5254493e20d0ea4a223efb1779f8207b1d34649606880525c00a48f530b7ec9ca
+  data.tar.gz: 1e3bbbc9b83448f8f33616b756262f91e48f59e179ba85f13c8d638bc8f032853fcd070c08194eb11e179bf2de72b1c8d05ee2ae0b43a7321bf3489958886c34

data/app/assets/javascripts/yummy_guide_administrate/sticky_table_headers.js

@@ -345,13 +345,14 @@
     });
   }
 
+  function mergeMeasuredCellWidths(widths, cells) {
+    cells.forEach(function(cell, index) {
+      widths[index] = Math.max(widths[index] || 0, measuredWidth(cell));
+    });
+  }
+
   function widthCandidateRows(sourceTable, headerCellCount) {
     var candidates = [];
-    var headerRow = sourceTable.querySelector('thead tr');
-
-    if (headerRow) {
-      candidates.push(headerRow);
-    }
 
     Array.from(sourceTable.querySelectorAll('tbody tr, tfoot tr')).forEach(function(row) {
       var cells = directCells(row);
@@ -363,13 +364,6 @@
     return candidates;
   }
 
-  function hasMeasurableDataRow(sourceTable, headerCellCount) {
-    return Array.from(sourceTable.querySelectorAll('tbody tr, tfoot tr')).some(function(row) {
-      var cells = directCells(row);
-      return cells.length === headerCellCount && !cells.some(function(cell) { return cell.colSpan > 1; });
-    });
-  }
-
   function removeGeneratedColGroup(table) {
     if (!table) return;
 
@@ -379,20 +373,87 @@
     }
   }
 
-  function generatedColGroupWidths(table, expectedCount) {
-    if (!table) return [];
-
-    var colgroup = table.querySelector('colgroup[data-fixed-header-colgroup]');
-    if (!colgroup) return [];
+  function clearSourceColumnMinWidths(sourceTable) {
+    if (!sourceTable) return;
 
-    var widths = Array.from(colgroup.children).map(function(col) {
-      var inlineWidth = parseFloat(col.style.width || '0');
-      return Number.isNaN(inlineWidth) ? 0 : preciseNumber(inlineWidth);
+    Array.from(sourceTable.querySelectorAll('[data-fixed-header-column-min-width]')).forEach(function(cell) {
+      restoreManagedCellWidth(cell, 'width');
+      restoreManagedCellWidth(cell, 'min-width');
+      cell.style.removeProperty('--fixed-header-column-min-width');
+      cell.removeAttribute('data-fixed-header-column-min-width');
     });
+  }
+
+  function managedWidthAttributeName(kind, propertyName) {
+    return 'data-fixed-header-' + kind + '-' + propertyName;
+  }
 
-    if (expectedCount && widths.length !== expectedCount) return [];
+  function storeOriginalCellWidth(cell, propertyName) {
+    var originalAttribute = managedWidthAttributeName('original', propertyName);
+    var originalPriorityAttribute = managedWidthAttributeName('original-priority', propertyName);
 
-    return widths;
+    if (cell.hasAttribute(originalAttribute)) return;
+
+    cell.setAttribute(originalAttribute, cell.style.getPropertyValue(propertyName));
+    cell.setAttribute(originalPriorityAttribute, cell.style.getPropertyPriority(propertyName));
+  }
+
+  function applyManagedCellWidth(cell, propertyName, value) {
+    storeOriginalCellWidth(cell, propertyName);
+    cell.style.setProperty(propertyName, value, 'important');
+    cell.setAttribute(managedWidthAttributeName('applied', propertyName), value);
+    cell.setAttribute(managedWidthAttributeName('applied-priority', propertyName), 'important');
+  }
+
+  function restoreManagedCellWidth(cell, propertyName) {
+    var originalAttribute = managedWidthAttributeName('original', propertyName);
+    var originalPriorityAttribute = managedWidthAttributeName('original-priority', propertyName);
+    var appliedAttribute = managedWidthAttributeName('applied', propertyName);
+    var appliedPriorityAttribute = managedWidthAttributeName('applied-priority', propertyName);
+    var appliedValue = cell.getAttribute(appliedAttribute);
+    var appliedPriority = cell.getAttribute(appliedPriorityAttribute);
+
+    if (
+      appliedValue === null ||
+      (
+        cell.style.getPropertyValue(propertyName) === appliedValue &&
+        cell.style.getPropertyPriority(propertyName) === (appliedPriority || '')
+      )
+    ) {
+      var originalValue = cell.getAttribute(originalAttribute);
+      var originalPriority = cell.getAttribute(originalPriorityAttribute) || '';
+
+      if (originalValue) {
+        cell.style.setProperty(propertyName, originalValue, originalPriority);
+      } else {
+        cell.style.removeProperty(propertyName);
+      }
+    }
+
+    cell.removeAttribute(originalAttribute);
+    cell.removeAttribute(originalPriorityAttribute);
+    cell.removeAttribute(appliedAttribute);
+    cell.removeAttribute(appliedPriorityAttribute);
+  }
+
+  function applySourceColumnMinWidths(sourceTable, widths) {
+    if (!sourceTable || !widths.length) return;
+
+    Array.from(sourceTable.querySelectorAll('thead tr, tbody tr, tfoot tr')).forEach(function(row) {
+      var cells = directCells(row);
+      if (cells.length !== widths.length || cells.some(function(cell) { return cell.colSpan > 1; })) return;
+
+      cells.forEach(function(cell, index) {
+        var width = widths[index];
+        if (!width) return;
+
+        var widthValue = cssPixelValue(width);
+        cell.style.setProperty('--fixed-header-column-min-width', widthValue);
+        applyManagedCellWidth(cell, 'width', widthValue);
+        applyManagedCellWidth(cell, 'min-width', widthValue);
+        cell.setAttribute('data-fixed-header-column-min-width', 'true');
+      });
+    });
   }
 
   function clearFixedHeaderState(slot, scroll, sourceTable) {
@@ -403,6 +464,7 @@
     if (!sourceTable) return;
 
     removeGeneratedColGroup(sourceTable);
+    clearSourceColumnMinWidths(sourceTable);
     sourceTable.classList.remove('table-with-fixed-header');
 
     if (sourceTable.classList.contains('home-table')) {
@@ -425,25 +487,14 @@
     var widths = headerCells.map(function() { return 0; });
 
     widthCandidateRows(sourceTable, headerCells.length).forEach(function(row) {
-      directCells(row).forEach(function(cell, index) {
-        widths[index] = Math.max(widths[index], measuredWidth(cell));
-      });
+      mergeMeasuredCellWidths(widths, directCells(row));
     });
 
-    if (!widths.some(Boolean)) {
-      var generatedWidths = generatedColGroupWidths(sourceTable, headerCells.length);
-      if (generatedWidths.length) {
-        widths = generatedWidths.slice();
-      }
-    }
-
-    if (!widths.some(Boolean) && fixedTable && settings.allowFixedTableFallback !== false) {
+    if (fixedTable && settings.allowFixedTableFallback !== false) {
       var fixedRow = fixedTable.querySelector('thead tr');
       var fixedCells = fixedRow ? directCells(fixedRow) : [];
 
-      fixedCells.forEach(function(cell, index) {
-        widths[index] = Math.max(widths[index] || 0, measuredWidth(cell));
-      });
+      mergeMeasuredCellWidths(widths, fixedCells);
     }
 
     return widths;
@@ -483,13 +534,16 @@
 
     var sourceRow = sourceHead.querySelector('tr');
     var headerCells = sourceRow ? directCells(sourceRow) : [];
-    var hasDataRow = hasMeasurableDataRow(sourceTable, headerCells.length);
 
     if (!headerCells.length) {
       clearFixedHeaderState(slot, scroll, sourceTable);
       return;
     }
 
+    slot.hidden = false;
+    removeGeneratedColGroup(sourceTable);
+    clearSourceColumnMinWidths(sourceTable);
+
     var fixedScroll = ensureFixedHeaderScrollViewport(slot);
     var fixedTable = fixedScroll.querySelector('.table-fixed-header__table');
     var fixedSpacer = ensureFixedHeaderSpacer(fixedScroll);
@@ -501,6 +555,7 @@
 
     fixedTable.className = fixedHeaderTableClassName(sourceTable);
     fixedTable.dataset.fixedColumnsCount = sourceTable.dataset.fixedColumnsCount || '0';
+    fixedTable.style.width = '';
     fixedTable.innerHTML = sourceHead.outerHTML;
 
     if (fixedTable.parentNode !== fixedScroll) {
@@ -509,15 +564,13 @@
       fixedScroll.appendChild(fixedSpacer);
     }
 
-    var widths = measuredColumnWidths(sourceTable, fixedTable, {
-      allowFixedTableFallback: hasDataRow
-    });
+    var widths = measuredColumnWidths(sourceTable, fixedTable);
     if (!widths.some(Boolean)) {
       clearFixedHeaderState(slot, scroll, sourceTable);
       return;
     }
 
-    applyColGroup(sourceTable, widths);
+    applySourceColumnMinWidths(sourceTable, widths);
     applyColGroup(fixedTable, widths);
     applyFixedHeaderCellWidths(fixedTable, widths);
     applyFixedHeaderStickyColumns(sourceTable, fixedTable, widths);

data/app/assets/stylesheets/yummy_guide_administrate/components.scss

@@ -402,6 +402,12 @@ td.actions-column .sticky__item,
   display: none;
 }
 
+table[data-fixed-columns-count] [data-fixed-header-column-min-width] {
+  box-sizing: border-box;
+  width: var(--fixed-header-column-min-width);
+  min-width: var(--fixed-header-column-min-width);
+}
+
 [data-fixed-table-header] .table-fixed-header__table {
   width: max-content;
   min-width: 100%;

data/lib/yummy_guide/administrate/version.rb

@@ -2,6 +2,6 @@
 
 module YummyGuide
   module Administrate
-    VERSION = "0.5.0"
+    VERSION = "0.5.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yummy-guide-generic-administrate
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - akatsuki-kk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: administrate