datastake-daf 0.6.302 → 0.6.304

package/src/@daf/core/components/PdfForm/index.js

@@ -525,404 +525,8 @@ const PdfForm = ({
 
   const organizedForm = useMemo(() => organizeFormByHeaders(form), [form]);
 
-  // Constants for height calculations (same as PdfView)
-  const PAGE_HEIGHT = 1587;
-  const FOOTER_HEIGHT = 70;
-  const HEADER_HEIGHT = 100;
-
-  // Detect if running in headless/Puppeteer environment (more conservative detection)
-  const isPuppeteerEnvironment = () => {
-    if (typeof window === 'undefined') return false;
-    
-    // Only trigger on explicit URL parameters (most reliable)
-    return (
-      window.location.search.includes('puppeteer=true') ||
-      window.location.search.includes('headless=true') ||
-      window.location.search.includes('pdf=true') ||
-      // Only very specific headless browser indicators
-      (window.navigator.webdriver === true && window.navigator.userAgent.includes('HeadlessChrome'))
-    );
-  };
-
-  // Debug function to log detection results (can be removed later)
-  const debugEnvironment = () => {
-    if (typeof window !== 'undefined' && window.console) {
-      console.log('Environment Detection:', {
-        isPuppeteer: isPuppeteerEnvironment(),
-        userAgent: window.navigator.userAgent,
-        webdriver: window.navigator.webdriver,
-        resizeObserver: !!window.ResizeObserver,
-        urlParams: window.location.search
-      });
-    }
-  };
-
-  // Balanced height estimation that prevents over-splitting while ensuring content fits
-  const estimateTreeNodeHeight = (key, config, value, level = 0) => {
-    const isPuppeteer = isPuppeteerEnvironment();
-    // Call debug only once to avoid spam
-    if (level === 0 && key === Object.keys(form)[0]) {
-      debugEnvironment();
-    }
-    
-    // More accurate base heights that align better with PdfView's ResizeObserver measurements
-    const baseHeight = isPuppeteer ? 48 : 38; // More accurate base heights to match actual rendering
-    const indentHeight = level * (isPuppeteer ? 4 : 3.5); // More accurate indent space
-    let totalHeight = baseHeight + indentHeight;
-
-    // Reasonable type-based adjustments based on actual rendered heights
-    if (config?.type === 'header') {
-      totalHeight += isPuppeteer ? 25 : 18; // Headers with reasonable padding
-    } else if (config?.type === 'textarea') {
-      totalHeight += isPuppeteer ? 60 : 45; // Textareas with multiline content
-    } else if (config?.type === 'dataLink' || config?.type === 'dataLinkGroup') {
-      totalHeight += isPuppeteer ? 35 : 25; // Data links with formatted content
-    } else if (config?.type === 'groupInputs') {
-      totalHeight += isPuppeteer ? 45 : 35; // Group inputs with structured layout
-    } else if (config?.type === 'ajaxSubGroup') {
-      totalHeight += isPuppeteer ? 50 : 40; // Ajax content with loading states
-    }
-
-    // More accurate content height estimation that better matches actual DOM measurements
-    if (value && typeof value === 'string') {
-      const cleanValue = value.trim();
-      if (cleanValue.length > 150) {
-        // Long text: be more generous with line estimates
-        const estimatedLines = Math.ceil(cleanValue.length / 45); // Shorter assumed line length
-        const lineHeight = isPuppeteer ? 20 : 18; // Slightly taller line height
-        totalHeight += estimatedLines * lineHeight;
-      } else if (cleanValue.length > 60) {
-        // Medium text: likely spans 2-3 lines
-        totalHeight += isPuppeteer ? 35 : 28;
-      } else if (cleanValue.length > 15) {
-        // Short-medium text: single to double line
-        totalHeight += isPuppeteer ? 18 : 14;
-      } else if (cleanValue.length > 0) {
-        // Very short text: single line with padding
-        totalHeight += isPuppeteer ? 12 : 10;
-      }
-    }
-
-    // Add height for children recursively with balanced multiplier
-    if (config?.inputs) {
-      const childKeys = Object.keys(config.inputs)
-        .filter(childKey => {
-          const childConfig = config.inputs[childKey];
-          // Check showIf condition
-          if (childConfig?.showIf && !evaluateShowIfCondition(childConfig.showIf, data)) {
-            return false;
-          }
-          return true;
-        })
-        .sort((a, b) => {
-          const positionA = config.inputs[a]?.position || 0;
-          const positionB = config.inputs[b]?.position || 0;
-          return positionA - positionB;
-        });
-      
-      let childrenHeight = 0;
-      childKeys.forEach(childKey => {
-        const childConfig = config.inputs[childKey];
-        const childValue = value?.[childKey] || data?.[childKey];
-        childrenHeight += estimateTreeNodeHeight(childKey, childConfig, childValue, level + 1);
-      });
-      
-      // More accurate multiplier that accounts for spacing and margins in actual DOM
-      totalHeight += childrenHeight * (isPuppeteer ? 1.25 : 1.15);
-    }
-
-    // Handle array/repeated content with accurate estimates
-    if (Array.isArray(value) && value.length > 0) {
-      value.forEach(itemValue => {
-        const itemHeight = estimateTreeNodeHeight(key, config, itemValue, level);
-        totalHeight += itemHeight * (isPuppeteer ? 1.1 : 1.05); // Minimal buffer
-      });
-    }
-
-    // Minimal buffer for deep nesting
-    if (level > 3) {
-      totalHeight *= (isPuppeteer ? 1.08 : 1.05);
-    }
-
-    return Math.ceil(totalHeight);
-  };
-
-  // Helper function to split section based on height constraints (aligned with PdfView calculations)
-  const createHeightConstrainedSections = (sectionKey, section) => {
-    const isPuppeteer = isPuppeteerEnvironment();
-    
-    // Align with PdfView but use a more conservative limit to prevent large margin calculations
-    // PdfView uses PAGE_HEIGHT - 30 - FOOTER_HEIGHT - HEADER_HEIGHT = 1387px
-    // We'll use 85% of that to ensure sections fit comfortably and don't trigger large margins
-    const PDFVIEW_MAX_HEIGHT = PAGE_HEIGHT - 30 - FOOTER_HEIGHT - HEADER_HEIGHT; // 1387px
-    const MAX_SECTION_HEIGHT = Math.floor(PDFVIEW_MAX_HEIGHT * 0.85); // ~1179px - more conservative
-    const MIN_SECTION_HEIGHT = 300; // Slightly larger minimum to ensure meaningful content
-    const subSections = [];
-    
-    // Get all top-level items in the section with detailed analysis
-    const topLevelItems = Object.keys(section)
-      .filter(key => !(key === 'id' || key === 'label' || key === 'position' || key === 'subTitle'))
-      .map(key => ({
-        key,
-        config: section[key],
-        estimatedHeight: estimateTreeNodeHeight(key, section[key], data?.[key]),
-        canSplit: section[key]?.inputs && Object.keys(section[key].inputs).length > 3 // Only split if sufficient children
-      }))
-      .sort((a, b) => (a.config?.position || 0) - (b.config?.position || 0));
-
-    // If the entire section fits, don't split it
-    const totalSectionHeight = topLevelItems.reduce((sum, item) => sum + item.estimatedHeight, 0);
-    
-    // Add detailed debugging for height calculations
-    if (typeof window !== 'undefined' && window.console) {
-      console.log(`Section ${sectionKey}:`, {
-        totalEstimatedHeight: totalSectionHeight,
-        maxAllowedHeight: MAX_SECTION_HEIGHT,
-        pdfViewMaxHeight: PDFVIEW_MAX_HEIGHT,
-        utilizationPercentage: Math.round((totalSectionHeight / MAX_SECTION_HEIGHT) * 100) + '%',
-        shouldSplit: totalSectionHeight > MAX_SECTION_HEIGHT,
-        itemCount: topLevelItems.length,
-        itemSummary: topLevelItems.map(item => ({
-          key: item.key,
-          height: item.estimatedHeight,
-          type: item.config?.type
-        }))
-      });
-    }
-    
-    if (totalSectionHeight <= MAX_SECTION_HEIGHT) {
-      return [{
-        key: sectionKey,
-        section: section,
-        title: section.label
-      }];
-    }
-
-    let currentSubSection = {
-      ...section,
-    };
-    
-    // Remove all items from the base section structure
-    Object.keys(section).forEach(key => {
-      if (!(key === 'id' || key === 'label' || key === 'position' || key === 'subTitle')) {
-        delete currentSubSection[key];
-      }
-    });
-
-    let currentHeight = isPuppeteer ? 120 : 100; // More accurate base height including section headers and margins
-    let subSectionIndex = 0;
-
-    topLevelItems.forEach((item, index) => {
-      const { key, config, estimatedHeight, canSplit } = item;
-      
-      // More conservative splitting thresholds to work better with PdfView
-      const SPLIT_THRESHOLD = 0.65; // Split if item takes up more than 65% of available space
-      
-      // If a single item is large and can be split, consider splitting it
-      if (estimatedHeight > MAX_SECTION_HEIGHT * SPLIT_THRESHOLD && canSplit && estimatedHeight > MIN_SECTION_HEIGHT * 1.5) {
-        // Split this large item into smaller parts
-        const childSplits = splitLargeItem(key, config, data?.[key], MAX_SECTION_HEIGHT * 0.6);
-        
-        childSplits.forEach((splitItem, splitIndex) => {
-          // Check if current subsection has room - be more lenient about splitting
-          if (currentHeight + splitItem.estimatedHeight > MAX_SECTION_HEIGHT && 
-              currentHeight > MIN_SECTION_HEIGHT && 
-              Object.keys(currentSubSection).length > 4) {
-            
-            // Save current sub-section if it has meaningful content
-            subSections.push({
-              key: `${sectionKey}_part_${subSectionIndex}`,
-              section: { ...currentSubSection },
-              title: section.label
-            });
-
-            // Start new sub-section
-            currentSubSection = {
-              id: section.id,
-              label: section.label,
-              position: section.position + subSectionIndex + 1,
-              subTitle: section.subTitle
-            };
-            currentHeight = isPuppeteer ? 120 : 100;
-            subSectionIndex++;
-          }
-
-          // Add split item to current sub-section
-          currentSubSection[splitItem.key] = splitItem.config;
-          currentHeight += splitItem.estimatedHeight;
-        });
-      } else {
-        // Regular processing for items that fit or shouldn't be split
-        // More lenient threshold - only split if really necessary and ensures meaningful sections
-        const remainingItems = topLevelItems.length - index - 1;
-        const shouldSplitSection = (currentHeight + estimatedHeight > MAX_SECTION_HEIGHT) && 
-                                  (currentHeight > MIN_SECTION_HEIGHT * 0.8) && // More lenient minimum
-                                  (Object.keys(currentSubSection).length > 3) && // Fewer items required
-                                  (remainingItems > 0); // Ensure there are items left for next section
-        
-        if (shouldSplitSection) {
-          
-          // Save current sub-section
-          subSections.push({
-            key: `${sectionKey}_part_${subSectionIndex}`,
-            section: { ...currentSubSection },
-            title: section.label
-          });
-
-          // Start new sub-section
-          currentSubSection = {
-            id: section.id,
-            label: section.label,
-            position: section.position + subSectionIndex + 1,
-            subTitle: section.subTitle
-          };
-          currentHeight = isPuppeteer ? 120 : 100;
-          subSectionIndex++;
-        }
-
-        // Add item to current sub-section
-        currentSubSection[key] = config;
-        currentHeight += estimatedHeight;
-      }
-    });
-
-    // Add the final sub-section if it has meaningful content
-    const finalSectionKeys = Object.keys(currentSubSection).filter(key => 
-      !(key === 'id' || key === 'label' || key === 'position' || key === 'subTitle')
-    );
-    
-    if (finalSectionKeys.length > 0) {
-      const finalSubSection = {
-        key: subSectionIndex === 0 ? sectionKey : `${sectionKey}_part_${subSectionIndex}`,
-        section: currentSubSection,
-        title: section.label
-      };
-      
-      subSections.push(finalSubSection);
-      
-      // Debug final section creation
-      if (typeof window !== 'undefined' && window.console) {
-        console.log(`Final section ${finalSubSection.key}:`, {
-          itemCount: finalSectionKeys.length,
-          estimatedHeight: currentHeight,
-          utilizationPercentage: Math.round((currentHeight / MAX_SECTION_HEIGHT) * 100) + '%',
-          isWithinLimits: currentHeight <= MAX_SECTION_HEIGHT
-        });
-      }
-    }
-
-    // If we only have one section and it's not too large, return the original
-    if (subSections.length === 1 && subSections[0].key === sectionKey) {
-      return [{
-        key: sectionKey,
-        section: section,
-        title: section.label
-      }];
-    }
-
-    return subSections.length > 0 ? subSections : [{
-      key: sectionKey,
-      section: section,
-      title: section.label
-    }];
-  };
-
-  // Helper function to split large items at the child level (more intelligent splitting)
-  const splitLargeItem = (parentKey, parentConfig, parentValue, maxHeight) => {
-    if (!parentConfig?.inputs) {
-      return [{ key: parentKey, config: parentConfig, estimatedHeight: estimateTreeNodeHeight(parentKey, parentConfig, parentValue) }];
-    }
-
-    const childItems = Object.keys(parentConfig.inputs)
-      .filter(childKey => {
-        const childConfig = parentConfig.inputs[childKey];
-        return !childConfig?.showIf || evaluateShowIfCondition(childConfig.showIf, data);
-      })
-      .map(childKey => ({
-        key: childKey,
-        config: parentConfig.inputs[childKey],
-        estimatedHeight: estimateTreeNodeHeight(childKey, parentConfig.inputs[childKey], parentValue?.[childKey])
-      }))
-      .sort((a, b) => (a.config?.position || 0) - (b.config?.position || 0));
-
-    // If total children height is not that large, don't split
-    const totalChildrenHeight = childItems.reduce((sum, child) => sum + child.estimatedHeight, 0);
-    if (totalChildrenHeight <= maxHeight * 1.1) { // More conservative threshold
-      return [{ key: parentKey, config: parentConfig, estimatedHeight: estimateTreeNodeHeight(parentKey, parentConfig, parentValue) }];
-    }
-
-    const splits = [];
-    let currentSplit = {
-      key: `${parentKey}_part_0`,
-      config: {
-        ...parentConfig,
-        inputs: {}
-      },
-      estimatedHeight: 60 // More accurate base height for parent structure with styling
-    };
-    let splitIndex = 0;
-    const minItemsPerSplit = 2; // Ensure at least 2 items per split to avoid tiny sections
-
-    childItems.forEach((child, index) => {
-      const isLastChild = index === childItems.length - 1;
-      const currentSplitItemCount = Object.keys(currentSplit.config.inputs).length;
-      
-      // Only split if:
-      // 1. Adding this child would exceed max height
-      // 2. Current split has at least minimum items
-      // 3. There are enough remaining items to make another meaningful split
-      const remainingItems = childItems.length - index;
-      const shouldSplit = (currentSplit.estimatedHeight + child.estimatedHeight > maxHeight) && 
-                         (currentSplitItemCount >= minItemsPerSplit) &&
-                         (remainingItems > minItemsPerSplit || isLastChild);
-
-      if (shouldSplit) {
-        // Save current split if it has content
-        splits.push(currentSplit);
-        splitIndex++;
-        
-        // Start new split
-        currentSplit = {
-          key: `${parentKey}_part_${splitIndex}`,
-          config: {
-            ...parentConfig,
-            label: parentConfig.label, // Keep original label without part indicator
-            inputs: {}
-          },
-          estimatedHeight: 60
-        };
-      }
-
-      // Add child to current split
-      currentSplit.config.inputs[child.key] = child.config;
-      currentSplit.estimatedHeight += child.estimatedHeight;
-    });
-
-    // Add the final split if it has content
-    if (Object.keys(currentSplit.config.inputs).length > 0) {
-      splits.push(currentSplit);
-    }
-
-    // If we ended up with only one split, return original
-    if (splits.length <= 1) {
-      return [{ key: parentKey, config: parentConfig, estimatedHeight: estimateTreeNodeHeight(parentKey, parentConfig, parentValue) }];
-    }
-
-    return splits;
-  };
-
   const pdfConfig = useMemo(() => {
     const sections = [];
-    const isPuppeteer = isPuppeteerEnvironment();
-    
-    // Apply Puppeteer-specific class to document body if needed
-    if (typeof document !== 'undefined') {
-      if (isPuppeteer) {
-        document.body.setAttribute('data-puppeteer', 'true');
-      } else {
-        document.body.removeAttribute('data-puppeteer');
-      }
-    }
     
     Object.keys(organizedForm).forEach((sectionKey) => {
       const section = organizedForm[sectionKey];
@@ -931,32 +535,27 @@ const PdfForm = ({
         return;
       }
 
-      // Create height-constrained sub-sections
-      const subSections = createHeightConstrainedSections(sectionKey, section);
-      
-      subSections.forEach(({ key, section: subSection, title }) => {
-        sections.push({
-          render: () => (
-            <div key={key} className={`pdf-form-section ${isPuppeteer ? 'puppeteer-mode' : ''}`}>
-              <PdfFormContent
-                form={{ [key]: { ...subSection, label: title } }}
-                data={data}
-                t={t}
-                user={user}
-                title={formName}
-                source={source}
-                version={version}
-                getApiBaseUrl={getApiBaseUrl}
-                getAppHeader={getAppHeader}
-                app={app}
-              />
-            </div>
-          ),
-          style: {
-            marginBottom: '20px',
-            padding: '0 20px'
-          }
-        });
+      sections.push({
+        render: () => (
+          <div key={sectionKey} className="pdf-form-section">
+            <PdfFormContent
+              form={{ [sectionKey]: section }}
+              data={data}
+              t={t}
+              user={user}
+              title={formName}
+              source={source}
+              version={version}
+              getApiBaseUrl={getApiBaseUrl}
+              getAppHeader={getAppHeader}
+              app={app}
+            />
+          </div>
+        ),
+        style: {
+          marginBottom: '20px',
+          padding: '0 20px'
+        }
       });
     });
 
@@ -991,4 +590,4 @@ PdfForm.propTypes = {
   user: PropTypes.object,
 };
 
-export default PdfForm;
+export default PdfForm;

package/src/@daf/core/components/PdfForm/style.scss

@@ -59,24 +59,17 @@
   }
   
   .pdf-form-section {
-    margin-bottom: 20px; // Balanced spacing between sections
-    padding-bottom: 10px; // Balanced padding to avoid footers
+    margin-bottom: 40px;
     position: relative;
     width: 100%;
-    min-height: 50px; // Ensure minimum content height
-    
-    // Prevent completely empty sections
-    &:empty {
-      display: none;
-    }
     
     .section-header {
-      margin-bottom: 12px;
-      padding-bottom: 6px;
+      margin-bottom: 25px;
+      padding-bottom: 8px;
       border-bottom: 1px solid #ddd;
       
       h2 {
-        margin: 0 0 4px 0;
+        margin: 0 0 5px 0;
         font-size: 16px;
         font-weight: 700;
         color: #333;
@@ -105,8 +98,7 @@
       
       .tree-node {
         position: relative;
-        margin-bottom: 8px; // Reasonable spacing between tree nodes
-        padding: 1px 0; // Minimal padding
+        margin-bottom: 8px;
         
         &.parent {
           &::after {
@@ -489,27 +481,13 @@
   }
   
   @media print {
-    // Spacer to ensure content clears the floating header in print/PDF mode
-    .pdf-form-section:first-of-type::before {
-      content: "";
-      display: block;
-      height: 120px;
-      margin-bottom: 12px;
-    }
-
     .pdf-form-section {
-      page-break-inside: avoid;
+      // page-break-inside: avoid;
       margin-bottom: 20px;
-      padding-bottom: 10px; // Reasonable space before potential breaks
-      
-      // Prevent orphaned sections
-      &:empty {
-        display: none;
-      }
     }
     
     .pdf-tree .tree-node {
-      page-break-inside: avoid;
+      // page-break-inside: avoid;
       
       &::after,
       .tree-indent .indent-line::before,
@@ -519,52 +497,9 @@
         -webkit-print-color-adjust: exact;
       }
       
-      // Force page breaks for deeply nested content in print
-      &.level-0,
-      &.level-1 {
-        &.parent {
-          page-break-after: avoid;
-          margin-bottom: 15px;
-        }
-      }
-      
-      // More conservative spacing for print
-      .tree-node-content {
-        padding: 6px 0; // Slightly more padding
-        
-        .tree-node-title {
-          min-height: 28px; // Ensure minimum height
-        }
-      }
-    }
-  }
-  
-  // Balanced spacing for headless/PDF mode
-  &.puppeteer-mode,
-  body[data-puppeteer="true"] & {
-    .pdf-form-section {
-      margin-bottom: 30px;
-      padding: 8px 0;
-      
-      &:last-child {
-        margin-bottom: 40px;
-      }
-    }
-    
-    .pdf-tree .tree-node {
-      margin-bottom: 10px;
-      
-      .tree-node-content {
-        padding: 6px 0;
-      }
-      
-      &.level-0 {
-        margin-bottom: 18px;
-      }
-      
-      &.level-1 {
-        margin-bottom: 12px;
-      }
+      // &.parent {
+      //   page-break-after: avoid;
+      // }
     }
   }
 }
@@ -685,4 +620,4 @@
   .tree-node-content {
     padding-left: 10px;
   }
-}
+}