@trebco/treb 29.4.1 → 29.5.1

package/treb-export/src/{export2.ts → export.ts}

@@ -34,15 +34,15 @@ import { PixelsToColumnWidth } from './column-width';
 const XMLDeclaration = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n`;
 
 import { template } from './template-2';
-import type { SerializedModel, SerializedSheet, DataValidation } from 'treb-data-model';
+import type { SerializedModel, SerializedSheet } from 'treb-data-model';
 
-import type { IArea, ICellAddress, CellValue, CellStyle,
-         AnnotationLayout, Corner as LayoutCorner, Cell, Rectangle } from 'treb-base-types';
-import { Area, Cells, ValueType, Style } from 'treb-base-types';
+import type { IArea, ICellAddress, CellStyle,
+         AnnotationLayout, Corner as LayoutCorner, Cell, Rectangle, Color } from 'treb-base-types';
+import { Area, Cells, ValueType, Style, IsHTMLColor, IsThemeColor, ThemeColorIndex } from 'treb-base-types';
 
 // import * as xmlparser from 'fast-xml-parser';
 import type { XmlBuilderOptions} from 'fast-xml-parser';
-import { XMLParser, XMLBuilder } from 'fast-xml-parser';
+import { XMLParser } from 'fast-xml-parser';
 
 import { SharedStrings } from './shared-strings2';
 import type { XlColor, BorderEdge } from './workbook-style2';
@@ -51,7 +51,7 @@ import { Theme } from './workbook-theme2';
 
 import type { RelationshipMap} from './relationship';
 import { AddRel } from './relationship';
-import { type DOMContent, XMLOptions2 } from './xml-utils';
+import { type DOMContent, XMLOptions2, PatchXMLBuilder } from './xml-utils';
 
 import type { UnitAddress, UnitRange, ExpressionUnit} from 'treb-parser';
 import { Parser } from 'treb-parser';
@@ -72,6 +72,39 @@ interface NestedDOMType {
 }
 */
 
+/**
+ * utility function. given a Color object (our Color, from Style) returns 
+ * an XML structure like 
+ * 
+ * { a$: { rgb: '123456 }}
+ * 
+ * or
+ * 
+ * { a$: { theme: 1, tint: .5 }}
+ * 
+ */
+const ColorAttrs = (color?: Color): DOMContent|undefined => {
+
+  if (IsHTMLColor(color)) {
+    return { 
+      a$: {
+        rgb: `FF` + color.text.substring(1),
+      },
+    };
+  }
+  if (IsThemeColor(color)) {
+    return {
+      a$: {
+        theme: ThemeColorIndex(color),
+        tint: color.tint,
+      },
+    };
+  }
+
+  return undefined;
+  
+};
+
 export class Exporter {
 
   // public zip?: JSZip;
@@ -119,7 +152,7 @@ export class Exporter {
   };
 
   // public xmlparser = new xmlparser.j2xParser(this.xmloptions);
-  public xmlbuilder1 = new XMLBuilder(this.xmloptions);
+  public xmlbuilder1 = PatchXMLBuilder(this.xmloptions);
   public xmlparser2 = new XMLParser(XMLOptions2);
 
   // FIXME: need a way to share/pass parser flags
@@ -217,7 +250,8 @@ export class Exporter {
       if (color.argb !== undefined) {
         attrs.rgb = color.argb;
       }
-      return attrs;
+
+      return attrs as DOMContent;
 
     };
 
@@ -255,7 +289,7 @@ export class Exporter {
       return block;
     });
 
-    const BorderColorAttributes = (edge: BorderEdge) => {
+    const BorderColorAttributes= (edge: BorderEdge): DOMContent|undefined  => {
       if (edge.color) {
         return { indexed: edge.color };
       }
@@ -263,131 +297,174 @@ export class Exporter {
         return { rgb: edge.rgba };
       }
       if (edge.theme) {
-        const attrs: any = {
+        return {
           theme: edge.theme,
-        }
-        if (edge.tint) {
-          attrs.tint = edge.tint;
-        }
-        return attrs;
+          tint: edge.tint,
+        };
       }
       return undefined;
     };
 
     const borders = style_cache.borders.map(border => {
-      const block: any = {
-        left: {},
-        right: {},
-        top: {},
-        bottom: {},
-        diagonal: {},
-      };
+
+      const top: DOMContent = {};
+      const left: DOMContent = {};
+      const right: DOMContent = {};
+      const bottom: DOMContent = {};
+      const diagonal: DOMContent = {};
 
       if (border.top.style) {
-        block.top.a$ = {
+        top.a$ = {
           style: border.top.style,
         };
         const attrs = BorderColorAttributes(border.top);
-        if (attrs) { block.top.color = {a$: attrs}; }
+        if (attrs) { top.color = {a$: attrs}; }
       }
 
       if (border.left.style) {
-        block.left.a$ = {
+        left.a$ = {
           style: border.left.style,
         };
         const attrs = BorderColorAttributes(border.left);
-        if (attrs) { block.left.color = {a$: attrs}; }
+        if (attrs) { left.color = {a$: attrs}; }
       }
 
       if (border.bottom.style) {
-        block.bottom.a$ = {
+        bottom.a$ = {
           style: border.bottom.style,
         };
         const attrs = BorderColorAttributes(border.bottom);
-        if (attrs) { block.bottom.color = {a$: attrs}; }
+        if (attrs) { bottom.color = {a$: attrs}; }
       }
 
       if (border.right.style) {
-        block.right.a$ = {
+        right.a$ = {
           style: border.right.style,
         };
         const attrs = BorderColorAttributes(border.right);
-        if (attrs) { block.right.color = {a$: attrs}; }
+        if (attrs) { right.color = {a$: attrs}; }
       }
 
       if (border.diagonal.style) {
-        block.diagonal.a$ = {
+        diagonal.a$ = {
           style: border.diagonal.style,
         };
         const attrs = BorderColorAttributes(border.diagonal);
-        if (attrs) { block.diagonal.color = {a$: attrs}; }
+        if (attrs) { diagonal.color = {a$: attrs}; }
       }
 
-      return block;
+      return {
+        left,
+        right,
+        top,
+        bottom,
+        diagonal,
+      };
+
     });
 
-    // console.info("SC", style_cache);
+    const fills: DOMContent[] = style_cache.fills.map(fill => ({
+      patternFill: {
+        a$: { 
+          patternType: (fill.pattern_gray !== undefined) ? `gray${fill.pattern_gray}` : fill.pattern_type,
+        },
 
-    const fills = style_cache.fills.map(fill => {
-      const block: any = {
-        a$: { patternType: fill.pattern_type },
-      };
+        bgColor: fill.bg_color ? {
+          a$: ColorAttributes(fill.bg_color),
+        } : undefined,
 
-      if (fill.pattern_gray !== undefined) {
-        block.a$.patternType = `gray${fill.pattern_gray}`;
-      }
-      if (fill.bg_color) {
-        block.bgColor = { a$: ColorAttributes(fill.bg_color) };
-      }
-      if (fill.fg_color) {
-        block.fgColor = { a$: ColorAttributes(fill.fg_color) };
+        fgColor: fill.fg_color ? {
+          a$: ColorAttributes(fill.fg_color),
+        } : undefined,
+      },
+    }));
+
+    const ValProp = (prop: string|number|undefined) => {
+      
+      if (typeof prop === 'undefined') {
+        return undefined;
       }
 
-      return {patternFill: block};
-    });
+      return {
+        a$: {
+          val: prop,
+        },
+      };
+
+    };
 
-    const fonts = style_cache.fonts.map(font => {
-      const block: any = {};
+    const fonts: DOMContent[] = style_cache.fonts.map(font => {
 
-      // flags
+      return {
 
-      if (font.bold) { block.b = ''; }
-      if (font.italic) { block.i = ''; }
-      if (font.underline) { block.u = ''; }
-      if (font.strike) { block.strike = ''; }
+        // flags 
 
-      // "val" props
+        b: font.bold ? '' : undefined,
+        i: font.italic ? '' : undefined,
+        u: font.underline ? '' : undefined,
+        strike: font.strike ? '' : undefined,
 
-      if (font.size !== undefined) {
-        block.sz = { a$: { val: font.size }};
-      }
-      if (font.family !== undefined) {
-        block.family = { a$: { val: font.family }};
-      }
-      if (font.name !== undefined) {
-        block.name = { a$: { val: font.name }};
-      }
-      if (font.scheme !== undefined) {
-        block.scheme = { a$: { val: font.scheme }};
-      }
+        // 'val' props
 
-      // color
+        sz: ValProp(font.size),
+        family: ValProp(font.family),
+        name: ValProp(font.name),
+        scheme: ValProp(font.scheme),
 
-      if (font.color_argb !== undefined) {
-        block.color = { a$: { rgb: font.color_argb }};
+        color: font.color_argb ? {
+          a$: { rgb: font.color_argb },
+        } : font.color_theme ? {
+          a$: { 
+            theme: font.color_theme,
+            tint: font.color_tint,
+          },
+        } : undefined,
+
+      };
+
+    });
+
+    const WithCount = (key: string, source: DOMContent[]) => {
+      if (source.length) {
+        return {
+          a$: { count: source.length },
+          [key]: source,
+        };
       }
-      else if (font.color_theme !== undefined) {
-        block.color = { a$: { theme: font.color_theme }};
-        if (font.color_tint) {
-          block.color.a$.tint = font.color_tint;
-        }
+      return undefined;
+    };
+
+
+    const dxf: DOMContent[] = style_cache.dxf_styles.map(style => {
+
+      const entry: DOMContent = {
+        fill: style.fill ? {
+          patternFill: {
+            bgColor: ColorAttrs(style.fill),
+          },
+        } : undefined,
+      };
+
+      if (style.text || style.bold || style.italic || style.underline) {
+        entry.font = {
+          b: style.bold ? {} : undefined,
+          i: style.italic ? {} : undefined,
+          u: style.underline ? {} : undefined,
+          strike: style.strike ? {} : undefined,
+          color: ColorAttrs(style.text),
+        };
       }
 
-      return block;
+      return entry;
+
     });
 
+    // console.info({dxf});
+
     const dom: DOMContent = {
+
       styleSheet: {
+
         a$: {
           'xmlns':        'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
           'xmlns:mc':     'http://schemas.openxmlformats.org/markup-compatibility/2006',
@@ -396,131 +473,34 @@ export class Exporter {
           'xmlns:x16r2':  'http://schemas.microsoft.com/office/spreadsheetml/2015/02/main', 
           'xmlns:xr':     'http://schemas.microsoft.com/office/spreadsheetml/2014/revision',
         },
-      },
-    };
-
-    // we're only adding elements here if they are not empty, but in 
-    // practice only numFmts can be empty (because there are implicit 
-    // formats); everything else has a default 0 entry
-
-    if (style_cache.number_formats.length) {
-
-      (dom.styleSheet as DOMContent).numFmts = {
-        a$: { count: style_cache.number_formats.length },
-        numFmt: style_cache.number_formats.map(format => {
-          return {
-            a$: {
-              numFmtId: format.id,
-              formatCode: format.format,
-            } as DOMContent,  
-          };
-        }),
-      };
-
-      // console.info(style_cache.number_formats);
-      // console.info(dom.styleSheet.numFmts);
-
-    }
-
-    if (fonts.length) {
-      (dom.styleSheet as DOMContent).fonts = {
-        a$: { count: fonts.length },
-        font: fonts,
-      };
-    }
-
-    if (fills.length) {
-      (dom.styleSheet as DOMContent).fills = {
-        a$: { count: fills.length },
-        fill: fills,
-      };
-    }
 
-    if (borders.length) {
-      (dom.styleSheet as DOMContent).borders = {
-        a$: { count: borders.length },
-        border: borders,
-      };
-    }
-
-    // console.info("B", borders, JSON.stringify(dom.styleSheet.borders, undefined, 2))
-
-    if (xfs.length) {
-      (dom.styleSheet as DOMContent).cellXfs = {
-        a$: { count: xfs.length },
-        xf: xfs,
-      };
-    }
+        // we're only adding elements here if they are not empty, but in 
+        // practice only numFmts can be empty (because there are implicit 
+        // formats); everything else has a default 0 entry
 
-    if (style_cache.dxf_styles.length) {
-      const dxf: DOMContent[] = [];
-      for (const style of style_cache.dxf_styles) {
-        const entry: DOMContent = {};
-        if (style.text || style.bold || style.italic || style.underline) {
-          const font: DOMContent = {};
-          if (style.text) {
-            font.color = { a$: {}};
-            if (style.text.text) {
-              (font.color.a$ as DOMContent).rgb = `FF` + style.text.text.substring(1);
-            }
-            else if (style.text.theme) {
-              (font.color.a$ as DOMContent).theme = style.text.theme;
-              if (style.text.tint) {
-                (font.color.a$ as DOMContent).tint = style.text.tint;
-              }
-            }
-          }
-          if (style.bold) {
-            font.b = {};
-          }
-          if (style.italic) {
-            font.i = {};
-          }
-          if (style.underline) {
-            font.u = {};
-          }
-          if (style.strike) {
-            font.strike = {};
-          }
-          entry.font = font;
-        }
-        if (style.fill) {
-          const attrs: DOMContent = {};
-          if (style.fill.text) {
-            attrs.rgb = `FF` + style.fill.text.substring(1);
-          }
-          else if (style.fill.theme) {
-            attrs.theme = style.fill.theme;
-            if (style.fill.tint) {
-              attrs.tint = style.fill.tint;
-            }
-          }
-          const color: DOMContent = { a$: attrs };
-          entry.fill = { patternFill: { bgColor: color }};
-        }
-        dxf.push(entry);
-      }
-
-      if (dxf.length) {
-        (dom.styleSheet as DOMContent).dxfs = {
-          a$: { count: dxf.length },
-          dxf,
-        };
-      }
+        numFmts: style_cache.number_formats.length ? {
+          a$: { count: style_cache.number_formats.length },
+          numFmt: style_cache.number_formats.map(format => {
+            return {
+              a$: {
+                numFmtId: format.id,
+                formatCode: format.format,
+              } as DOMContent,  
+            };
+          }),
+        } : undefined,
+  
+        fonts: WithCount('font', fonts),
+        fills: WithCount('fill', fills),
+        borders: WithCount('border', borders),
+        cellXfs: WithCount('xf', xfs),
+        dxfs: WithCount('dxf', dxf),
 
-    }
+      },
 
-    // not used:
-    //
-    //  cellStyleXfs
-    //  cellStyles
-    //  tableStyles
-    
-    // ------------
+    };
 
     const xml = XMLDeclaration + this.xmlbuilder1.build(dom);
-    // console.info(xml);
-    
     this.zip?.Set('xl/styles.xml', xml);
 
   }
@@ -558,34 +538,6 @@ export class Exporter {
 
   }
 
-  /**
-   * FIXME: merge with workbook function (put somewhere else)
-   * /
-  public async ReadRels(zip?: JSZip, path = ''): Promise<RelationshipMap> {
-
-    const rels: RelationshipMap = {};
-    const data = await zip?.file(path)?.async('text') as string;
-    //
-    // force array on <Relationship/> elements, but be slack on the rest
-    // (we know they are single elements)
-    //
-    const xml = this.xmlparser2.parse(data || '');
-    console.info(path, xml);
-
-    for (const relationship of xml.Relationships?.Relationship || []) {
-      const id = relationship.a$.Id;
-      rels[id] = {
-        id, 
-        type: relationship.a$.Type,
-        target: relationship.a$.Target,
-      };
-    }
-
-    return rels;
-
-  }
-  */
-
   /**
    * FIXME: we might not always need this. 
    */
@@ -1292,80 +1244,6 @@ export class Exporter {
 
       const default_row_height = sheet.default_row_height ? (sheet.default_row_height / 20 * 15) : 15;
 
-      const dom: any = {
-        worksheet: {
-          a$: {
-            ...sheet_attributes,
-          },
-          dimension: {
-            a$: {
-              ref: 'A1',
-            },
-          },
-          sheetViews: {
-            sheetView: {
-              a$: {
-                // tabSelected: (sheet_index === active_sheet ? 1 : 0),
-                workbookViewId: 0,
-              },
-            },
-          },
-          sheetFormatPr: {
-            a$: default_row_height === 15 ? {
-              'x14ac:dyDescent': 0.25,
-            } : {
-              defaultRowHeight: default_row_height,
-              customHeight: 1,
-              'x14ac:dyDescent': 0.25,
-            },
-          },
-          cols: {},
-          sheetData: {},
-          mergeCells: {
-            a$: { count: 0 },
-          },
-          dataValidations: {},
-          hyperlinks: {},
-          conditionalFormatting: {},
-          pageMargins: {
-            a$: {
-              left: 0.7,
-              right: 0.7,
-              top: 0.75,
-              bottom: 0.75,
-              header: 0.3,
-              footer: 0.3,
-            },
-          },
-          drawing: {},
-          tableParts: {
-            a$: {
-              count: 0,
-            },
-          },
-          extLst: {
-            ext: {
-              a$: {
-                uri: '{05C60535-1F16-4fd2-B633-F4F36F0B64E0}',
-                'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
-              },
-            },
-          },
-
-        },
-      };
-
-      /*
-      const column_styles = (sheet.column_style as any) || {};
-
-      for (const key of Object.keys(column_styles)) {
-        console.info(key, '=>', column_styles[key]);
-
-      }
-
-      return;
-      */
-
       // data has different representations. it is either blocked into rows or 
       // columns, or a set of individual cells. we could theoretically guarantee
       // a particular encoding if we wanted to (by row would be optimal for excel).
@@ -1400,7 +1278,8 @@ export class Exporter {
 
       // cells data is row-major, and sparse.
 
-      const sheet_data: any = { row: [] };
+      // const sheet_data: any = { row: [] };
+      const sheet_rows: DOMContent[] = [];
 
       const hyperlinks: Array<{
         rel: string,
@@ -1417,13 +1296,6 @@ export class Exporter {
       const merges: Area[] = [];
       const tables: TableDescription[] = [];
       
-      /*
-      const validations: Array<{
-        address: ICellAddress,
-        validation: DataValidation,
-      }> = [];
-      */
-
       // --
 
       // 
@@ -1449,7 +1321,7 @@ export class Exporter {
 
           // row span
           const span = {start: -1, end: -1};
-          const row: any = [];
+          const row: DOMContent[] = [];
 
           for (let c = 0; c < cells.data[r].length; c++) {
 
@@ -1608,15 +1480,6 @@ export class Exporter {
                 });
               }
 
-              /*
-              if (cell.validation && (cell.validation.type === ValidationType.List || cell.validation.type === ValidationType.Range)) {
-                validations.push({
-                  address: {row: r, column: c},
-                  validation: cell.validation,
-                });
-              }
-              */
-
               // short-circuit here
               if (cell.type === ValueType.formula && /^=?sparkline\./i.test(cell.value as string)) {
                 sparklines.push({
@@ -1656,21 +1519,22 @@ export class Exporter {
               }
 
               // v (child element) is the value
-              let v: CellValue = undefined;
+
+              let v: string|number|undefined;
               let t: string|undefined;
-              let f: any; // string|undefined;
+              let f: DOMContent|string|undefined; // string|undefined;
 
               switch (cell.type) {
                 case ValueType.formula:
                   f = this.FormulaText(cell.value as string, cell);
                   switch (cell.calculated_type) {
                     case ValueType.string:
-                      v = cell.calculated;
+                      v = cell.calculated as string;
                       t = 'str';
                       break;
 
                     case ValueType.number:
-                      v = cell.calculated;
+                      v = cell.calculated as number;
                       break;
 
                     case ValueType.boolean:
@@ -1686,7 +1550,7 @@ export class Exporter {
                   break;
 
                 case ValueType.number:
-                  v = cell.value;
+                  v = cell.value as number;
                   break;
 
                 case ValueType.boolean:
@@ -1710,63 +1574,63 @@ export class Exporter {
                 }
               }
 
-              // zerp
-              const element: any = {
+              row.push({
                 a$: {
+
                   r: Area.CellAddressToLabel({row: r, column: c}),
-                  // t,
-                  // s,
-                },
-                // v,
-              };
+                  t,
 
-              if (t !== undefined) {
-                element.a$.t = t;
-              }
-              if (s !== undefined) {
+                  // old comment regarding `s`:
 
-                // we could skip this if it's equal to row style,
-                // or there is no row style and it's equal to column style
-                // or there is no column style and it's equal to sheet style
+                  // we could skip this if it's equal to row style,
+                  // or there is no row style and it's equal to column style
+                  // or there is no column style and it's equal to sheet style
 
-                element.a$.s = s;
+                  s,
+                },
 
-              }
-              if (f !== undefined) {
-                element.f = f;              
-              }
-              if (v !== undefined) {
-                element.v = v;
-              }
+                f,
+                v,
 
-              row.push(element);
+              });
 
             }
           }
 
           if (row.length || (row_style && row_style !== sheet_style)) {
 
-            const row_data: any = {
-              a$: {
-                r: r + 1,
-                spans: `${span.start + 1}:${span.end + 1}`, // this works out to 0:0 for an empty row, will that work?
-              },
-              c: row,
-            };
+            let customHeight: number|undefined = undefined;
+            let ht: number|undefined = undefined;
+
+            let s: number|undefined = undefined;
+            let customFormat: number|undefined = undefined;
+
             if (sheet.row_height 
-                && (typeof sheet.row_height[r] === 'number') 
-                && sheet.row_height[r] !== sheet.default_row_height) {
-              
-              row_data.a$.customHeight = 1;
-              row_data.a$.ht = sheet.row_height[r] * 3 / 4;
+              && (typeof sheet.row_height[r] === 'number') 
+              && sheet.row_height[r] !== sheet.default_row_height) {
+
+              customHeight = 1;
+              ht = sheet.row_height[r] * 3 / 4;
             }
 
             if (row_style && row_style !== sheet_style) {
-              row_data.a$.s = row_style;
-              row_data.a$.customFormat = 1;
+              s = row_style;
+              customFormat = 1;
             }
 
-            sheet_data.row.push(row_data);
+            // sheet_data.row.
+            sheet_rows.push({
+              a$: {
+                r: r + 1,
+                spans: `${span.start + 1}:${span.end + 1}`, // this works out to 0:0 for an empty row, will that work?
+                customHeight,
+                ht,
+                s,
+                customFormat,
+              },
+              c: row,
+            });
+
           }
 
         }
@@ -1787,11 +1651,6 @@ export class Exporter {
       // because we'll have a default entry for columns that have the 
       // sheet style. this is only for columns that are different.
 
-      if (sheet.default_column_width) {
-        dom.worksheet.sheetFormatPr.a$.defaultColWidth = // sheet.default_column_width * one_hundred_pixels / 100;
-          PixelsToColumnWidth(sheet.default_column_width);
-      }
-
       for (let c = 0; c < sheet.columns; c++) {
         const entry: { style?: number, width?: number, index: number } = { index: c };
         if (sheet.column_width 
@@ -1799,36 +1658,14 @@ export class Exporter {
             && (typeof sheet.column_width[c] === 'number')
             && sheet.column_width[c] !== sheet.default_column_width) {
 
-          entry.width = // sheet.column_width[c] * one_hundred_pixels / 100;
-            PixelsToColumnWidth(sheet.column_width[c]);
-
-          // console.info("COLUMN", c, 'width', sheet.column_width[c], 'calc?', entry.width, '100p', one_hundred_pixels);
-
+          entry.width = PixelsToColumnWidth(sheet.column_width[c]);
         }
 
-        let style = column_style_map[c];
+        const style = column_style_map[c];
         if (style && style !== sheet_style) {
           entry.style = style;
         }
 
-        /*
-        let style = sheet.column_style[c];
-       
-        if (typeof style === 'number') {
-          style = cell_style_refs[style];
-          if (style) {
-            entry.style = style_cache.EnsureStyle(style_cache.StyleOptionsFromProperties(style));
-          }
-        }
-        else if (style) {
-          entry.style = style_cache.EnsureStyle(style_cache.StyleOptionsFromProperties(style));
-        }
-        */
-
-        //if (sheet.column_style[c]) {
-        //  entry.style = style_cache.EnsureStyle(style_cache.StyleOptionsFromProperties(sheet.column_style[c]));
-        //}
-
         if (entry.style !== undefined || entry.width !== undefined) {
           column_entries[c] = entry;
         }
@@ -1837,9 +1674,11 @@ export class Exporter {
       // we're short-cutting here, these should be arranged in blocks if
       // there's overlap. not sure how much of an issue that is though.
       
+      let dom_cols: DOMContent|undefined;
+
       if (column_entries.length || sheet_style) {
 
-        const filled: any[] = [];
+        const filled: DOMContent[] = [];
         const default_column_width = PixelsToColumnWidth(sheet.default_column_width || 90);
 
         // FIXME: can merge these two branches
@@ -1863,25 +1702,13 @@ export class Exporter {
               });
             }
 
-            const a$: any = { 
+            filled.push({a$: { 
               min: entry.index + 1, 
               max: entry.index + 1,
-            };
-            if (entry.style === undefined) {
-              a$.style = sheet_style;
-            }
-            else {
-              a$.style = entry.style;
-            }
-            if (entry.width !== undefined) {
-              a$.width = entry.width;
-              a$.customWidth = 1;
-            }
-            else {
-              a$.width = default_column_width;
-            }
-
-            filled.push({a$});
+              style: entry.style === undefined ? sheet_style : entry.style,
+              width: entry.width === undefined ? default_column_width : entry.width,
+              customWidth: entry.width === undefined ? undefined : 1,
+            }});
 
             start_index = entry.index;
             
@@ -1898,44 +1725,20 @@ export class Exporter {
             });
           }
 
-          dom.worksheet.cols.col = filled;
+          dom_cols = { col: filled };
 
         }
 
-        /*
-        else {
-          dom.worksheet.cols.col = column_entries.map(entry => {
-            const a$: any = { 
-              min: entry.index + 1, 
-              max: entry.index + 1,
-            };
-            if (entry.style !== undefined) {
-              a$.style = entry.style;
-            }
-            if (entry.width !== undefined) {
-              a$.width = entry.width;
-              a$.customWidth = 1;
-            }
-            else {
-              a$.width = // (sheet.default_column_width || 100) / 100 * one_hundred_pixels;
-                default_column_width; // PixelsToColumnWidth(sheet.default_column_width || 90);
-            }
-            return {a$};
-          });
-        }
-        console.info({cols: dom.worksheet.cols});
-      */
-      }
-
-      else {
-        delete dom.worksheet.cols;
       }
 
       // --- validation ----------------------------------------------------------
 
+      let dataValidations: DOMContent|undefined;
+
       if (sheet.data_validations?.length) {
 
-        dom.worksheet.dataValidations = {
+        dataValidations = {
+
           a$: { count: sheet.data_validations.length },
           dataValidation: sheet.data_validations.map(validation => {
 
@@ -1943,15 +1746,8 @@ export class Exporter {
               return new Area(target.start, target.end).spreadsheet_label;
             }).join(' ');
 
-            const entry: any = { 
-              a$: {
-                type: 'list',
-                allowBlank: 1, 
-                showInputMessage: 1, 
-                showErrorMessage: 1, 
-                sqref, // : new Area(validation.address).spreadsheet_label,
-              },
-            };
+            let formula1: string|undefined = undefined;
+
             if (validation.type === 'range') {
 
               const range: UnitRange = {
@@ -1965,54 +1761,54 @@ export class Exporter {
                 ,
               }
 
-              console.info("AA", {validation});              
-
               if (typeof validation.area.start.sheet_id !== 'undefined') {
                 range.start.sheet = sheet_name_map[validation.area.start.sheet_id];
               }
 
-              console.info("m1");
-
-              /*
-              const area = new Area(
-                {...validation.validation.area.start, absolute_column: true, absolute_row: true}, 
-                {...validation.validation.area.end, absolute_column: true, absolute_row: true},
-              );
-
-              entry.formula1 = `${area.spreadsheet_label}`;
-              */
-              entry.formula1 = this.parser.Render(range);
+              formula1 = this.parser.Render(range);
 
             }
             else if (validation.type === 'list') {
-              entry.formula1 = `"${validation.list.join(',')}"`;
+              formula1 = `"${validation.list.join(',')}"`;
             }
-            return entry;
+
+            return { 
+              a$: {
+                type: 'list',
+                allowBlank: 1, 
+                showInputMessage: 1, 
+                showErrorMessage: 1, 
+                sqref, // : new Area(validation.address).spreadsheet_label,
+              },
+              formula1,
+            };
+
           }),
         };
 
       }
-      else {
-        delete dom.worksheet.dataValidations;
-      }
 
       // --- tables ------------------------------------------------------------
 
+      let tableParts: DOMContent|undefined;
+
       if (tables.length) {
-        dom.worksheet.tableParts.a$.count = tables.length;
-        dom.worksheet.tableParts.tablePart = tables.map(table => {
-          return {
-            a$: { 
-              'r:id': table.rel || '',
-            }
-          };
-        });
-      }
-      else {
-        delete dom.worksheet.tableParts;
+
+        tableParts = {
+          a$: {
+            count: tables.length,
+          },
+          tablePart: tables.map(table => {
+            return {
+              a$: { 
+                'r:id': table.rel || '',
+              }
+            };
+          }),
+        };
+
       }
 
-      // const GUID = () => '{' + uuidv4().toUpperCase() + '}';
 
       for (const table of tables) {
 
@@ -2021,47 +1817,23 @@ export class Exporter {
           totals_attributes.totalsRowCount = 1;
         }
         
-        const tableColumns: any = {
+        const tableColumns: DOMContent = {
           a$: {
             count: (table.columns || []).length,
           },
-          tableColumn: [],
-          /*
-          tableColumn: (table.columns||[]).map((column, index) => ({
-            a$: {
-              id: index + 1,
-              // 'xr3:uid': GUID(),
-              name: column || ('Column' + (index + 1)),
-            },
-          })),
-          */
-        };
-
-        if (table.columns) {
-          for (let i = 0; i < table.columns.length; i++) {
-            const column = table.columns[i];
+          tableColumn: (table.columns||[]).map((column, i) => {
             const footer = (table.footers || [])[i];
-            const obj: any = {
+            return {
               a$: {
                 id: i + 1,
                 name: column || `Column${i + 1}`,
+                totalsRowLabel: footer?.type === 'label' ? footer.value : undefined,
+                totalsRowFunction: footer?.type === 'formula' ? 'custom' : undefined,
               },
+              totalsRowFormula: footer?.type === 'formula' ? footer.value : undefined,
             };
-            
-            if (footer) {
-              if (footer.type === 'label') {
-                obj.a$.totalsRowLabel = footer.value;
-              }
-              else if (footer.type === 'formula') {
-                obj.a$.totalsRowFunction = 'custom';
-                obj.totalsRowFormula = footer.value;
-              }
-            }
-
-            tableColumns.tableColumn.push(obj);
-
-          }
-        }
+          }),
+        };
 
         const table_dom = {
           table: {
@@ -2072,18 +1844,15 @@ export class Exporter {
               'xmlns:xr': 'http://schemas.microsoft.com/office/spreadsheetml/2014/revision',
               'xmlns:xr3': 'http://schemas.microsoft.com/office/spreadsheetml/2016/revision3',
               id: table.index || 0, 
-              // 'xr:uid': '{676B775D-AA84-41B6-8450-8515A94D2D7B}',
               name: table.name, 
               displayName: table.display_name,
               ...totals_attributes,
               ref: table.ref,
-              // 'xr:uid': GUID(),
             },
 
             autoFilter: {
               a$: {
                 ref: table.filterRef || table.ref,
-                // 'xr:uid': GUID(),
               },
             },
 
@@ -2103,14 +1872,19 @@ export class Exporter {
         };
 
         const xml = XMLDeclaration + this.xmlbuilder1.build(table_dom);
+        // console.info(xml);
+
         this.zip?.Set(`xl/tables/table${table.index}.xml`, xml);
 
       }
 
       // --- conditional formats -----------------------------------------------
 
+      let conditionalFormatting: DOMContent|DOMContent[]|undefined;
+
       if (sheet.conditional_formats?.length) {
-        const conditionalFormatting: any[] = [];
+
+        const format_list: DOMContent[] = [];
         let priority_index = 1;
 
         const reverse_operator_map: Record<string, string> = {};
@@ -2150,7 +1924,7 @@ export class Exporter {
                 }
                 if (operator) {
 
-                  conditionalFormatting.push({
+                  format_list.push({
                     a$: { sqref: new Area(format.area.start, format.area.end).spreadsheet_label },
                     cfRule: {
                       a$: { type: 'cellIs', dxfId: dxf_index, operator, priority: priority_index++ },
@@ -2162,7 +1936,7 @@ export class Exporter {
               break;
 
             case 'expression':
-              conditionalFormatting.push({
+              format_list.push({
                 a$: { sqref: new Area(format.area.start, format.area.end).spreadsheet_label },
                 cfRule: {
                   a$: { type: 'expression', dxfId: dxf_index, priority: priority_index++ },
@@ -2172,7 +1946,7 @@ export class Exporter {
               break;
 
             case 'duplicate-values':
-              conditionalFormatting.push({
+              format_list.push({
                 a$: { sqref: new Area(format.area.start, format.area.end).spreadsheet_label },
                 cfRule: {
                   a$: { type: format.unique ? 'uniqueValues' : 'duplicateValues', dxfId: dxf_index, priority: priority_index++ },
@@ -2182,10 +1956,11 @@ export class Exporter {
 
             case 'gradient':
               {
-                let cfvo: any[] = [];
-                let color: any[] = [];
+                const cfvo: DOMContent[] = [];
+                const color: DOMContent[] = [];
 
                 for (const stop of format.stops) {
+
                   if (stop.value === 0) {
                     cfvo.push({ a$: { type: 'min' }}); 
                   }
@@ -2195,18 +1970,13 @@ export class Exporter {
                   else {
                     cfvo.push({ a$: { type: 'percentile', val: stop.value * 100 }}); 
                   }
-                  const stop_color: any = { a$: {}};
-                  if (stop.color.text) {
-                    stop_color.a$.rgb = 'FF' + stop.color.text.substring(1);
-                  }
-                  else if (stop.color.theme) {
-                    stop_color.a$.theme = stop.color.theme;
-                    stop_color.a$.tint = stop.color.tint || undefined;
-                  }
-                  color.push(stop_color);
+
+                  const attrs = ColorAttrs(stop.color);
+                  if (attrs) { color.push(attrs); }
+                  
                 }
 
-                const generated = {
+                const generated: DOMContent = {
                   a$: { sqref: new Area(format.area.start, format.area.end).spreadsheet_label },
                   cfRule: {
                     a$: { type: 'colorScale', priority: priority_index++ },
@@ -2217,60 +1987,60 @@ export class Exporter {
                   } 
                 };
 
-                conditionalFormatting.push(generated);
+                format_list.push(generated);
 
               }
               break;
           }
         }
 
-        if (conditionalFormatting.length) {
-          dom.worksheet.conditionalFormatting = (conditionalFormatting.length > 1) ? conditionalFormatting : conditionalFormatting[0];
-        }
-        else {
-          delete dom.worksheet.conditionalFormatting;
+        if (format_list.length) {
+          conditionalFormatting = (format_list.length > 1) ? format_list : format_list[0];
         }
 
       }
-      else {
-        delete dom.worksheet.conditionalFormatting;
-      }
 
       // --- merges ------------------------------------------------------------
 
+      let mergeCells: DOMContent|undefined;
       if (merges.length) {
-        dom.worksheet.mergeCells.a$.count = merges.length;
-        dom.worksheet.mergeCells.mergeCell = merges.map(merge => {
-          return {
-            a$: { ref: merge.spreadsheet_label }
-          };
-        });
-      }
-      else {
-        delete dom.worksheet.mergeCells;
+
+        mergeCells = {
+          a$: { count: merges.length },
+          mergeCell: merges.map(merge => {
+            return {
+              a$: { ref: merge.spreadsheet_label }
+            };
+          }),
+        };
+
       }
 
       // --- hyperlinks --------------------------------------------------------
 
+      let dom_hyperlinks: DOMContent|undefined;
+
       if (hyperlinks.length) {
-        dom.worksheet.hyperlinks.hyperlink = hyperlinks.map(link => {
-          return {
-            a$: {
-              'r:id': link.rel,
-              ref: new Area(link.address).spreadsheet_label,
-              'xr:uid': '{0C6B7792-7EA0-4932-BF15-D49C453C565D}',
-            },
-          };
-        });
-      }
-      else {
-        delete dom.worksheet.hyperlinks;
+        dom_hyperlinks = {
+          hyperlink: hyperlinks.map(link => {
+            return {
+              a$: {
+                'r:id': link.rel,
+                ref: new Area(link.address).spreadsheet_label,
+                'xr:uid': '{0C6B7792-7EA0-4932-BF15-D49C453C565D}',
+              },
+            };
+          }),
+        };
       }
 
       // --- sparklines --------------------------------------------------------
 
+      let extLst: DOMContent|undefined;
+
       if (sparklines.length) {
-        dom.worksheet.extLst.ext['x14:sparklineGroups'] = {
+
+        const groups: DOMContent = {
           a$: {
             'xmlns:xm': 'http://schemas.microsoft.com/office/excel/2006/main',
           },
@@ -2298,16 +2068,11 @@ export class Exporter {
               }
             }
 
-            const a$: any = {
-              displayEmptyCellsAs: 'gap',
-            };
-
-            if (/column/i.test(sparkline.formula)) {
-              a$.type = 'column';
-            }
-
             return {
-              a$,
+              a$: {
+                displayEmptyCellsAs: 'gap',
+                type: /column/i.test(sparkline.formula) ? 'column' : undefined,
+              },
               'x14:colorSeries': { a$: { rgb: 'FF376092' }},
               'x14:sparklines': {
                 'x14:sparkline': {
@@ -2318,15 +2083,25 @@ export class Exporter {
             }
           }),
         };
-      }
-      else {
-        delete dom.worksheet.extLst;
+
+        extLst = {
+          ext: {
+            a$: {
+              uri: '{05C60535-1F16-4fd2-B633-F4F36F0B64E0}',
+              'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
+            },
+            'x14:sparklineGroups': groups
+          }
+        };
+
+
       }
 
-      dom.worksheet.sheetData = sheet_data;
 
       // --- charts ------------------------------------------------------------
 
+      let dom_drawing: DOMContent|undefined;
+
       const charts = this.ParseCharts(sheet);
       const images = this.ParseImages(sheet);
       
@@ -2398,7 +2173,8 @@ export class Exporter {
             `http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing`, 
             `../drawings/drawing${drawing.index}.xml`);
 
-        dom.worksheet.drawing = {
+        // dom.worksheet.drawing = {
+        dom_drawing = {
           a$: {
             'r:id': drawing_rel,
           },
@@ -2406,7 +2182,7 @@ export class Exporter {
 
       }
       else {
-        delete dom.worksheet.drawing;
+        // delete dom.worksheet.drawing;
       }
 
       // --- move page margins -------------------------------------------------
@@ -2417,13 +2193,75 @@ export class Exporter {
 
       // --- end? --------------------------------------------------------------
 
+      const sheetFormatPr: DOMContent = {
+        a$: {
+          'x14ac:dyDescent': 0.25,
+          defaultRowHeight: default_row_height === 15 ? undefined : default_row_height,
+          customHeight: default_row_height === 15 ? undefined : 1,
+          defaultColWidth: sheet.default_column_width ? PixelsToColumnWidth(sheet.default_column_width) : undefined,
+        },
+      }
+
+      //------------------------------------------------------------------------
+      //
+      // NOTE: order matters. that's why we define the layout here. we 
+      // can't just append entries to the worksheet object. 
+      //
+      //------------------------------------------------------------------------
+
+      const dom: DOMContent = {
+
+        worksheet: {
+          a$: { ...sheet_attributes },
+          dimension: {
+            a$: {
+              ref: new Area(extent.start, extent.end).spreadsheet_label,
+            },
+          },
+          sheetViews: {
+            sheetView: {
+              a$: {
+                workbookViewId: 0,
+              },
+            },
+          },
+
+          sheetFormatPr,
+          cols: dom_cols,
+          sheetData: { row: sheet_rows },
+
+          mergeCells,
+          conditionalFormatting,
+          dataValidations,
+          hyperlinks: dom_hyperlinks,
+
+          pageMargins: {
+            a$: {
+              left: 0.7,
+              right: 0.7,
+              top: 0.75,
+              bottom: 0.75,
+              header: 0.3,
+              footer: 0.3,
+            },
+          },
+          drawing: dom_drawing,
+          tableParts,
+          extLst,
+
+        },
+      };
+
+      // -----------------------------------------------------------------------
+
       // it seems like chrome, at least, will maintain order. but this is 
       // not gauranteed and we can't rely on it. the best thing to do might
       // be to use the renderer on blocks and then assemble the blocks ourselves.
-
-      dom.worksheet.dimension.a$.ref = new Area(extent.start, extent.end).spreadsheet_label;
+     
       const xml = XMLDeclaration + this.xmlbuilder1.build(dom);
 
+      // console.info(xml);
+
       // write this into the file
 
        this.zip?.Set(`xl/worksheets/sheet${sheet_index + 1}.xml`, xml);
@@ -2459,15 +2297,12 @@ export class Exporter {
 
     this.WriteRels(workbook_rels, `xl/_rels/workbook.xml.rels`);
 
-    let definedNames: any = {definedName: []};
-
-    if (source.named) {
-      for (const entry of source.named) {
+    const definedNames: DOMContent|undefined = source.named?.length ? {
+      definedName: (source.named||[]).map(entry => {
 
         let scope: string|undefined = undefined;
 
         if (entry.scope) {
-
           const test = entry.scope.toLowerCase();
           for (const [index, sheet] of source.sheet_data.entries()) {
             if (sheet.name?.toLowerCase() === test) {
@@ -2477,20 +2312,16 @@ export class Exporter {
           }
         }
 
-        definedNames.definedName.push({
+        return {
           a$: { name: entry.name, localSheetId: scope },
           t$: entry.expression,
-        });
-
-      }
-    }
+        };
 
-    if (!definedNames.definedName.length) {
-      definedNames = undefined;
-    }
-    // else { console.info({definedNames}); }
+      }),
+    } : undefined;
+    
     
-    const workbook_dom: any = {
+    const workbook_dom: DOMContent = {
       workbook: {
         a$: {
           'xmlns': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
@@ -2516,17 +2347,14 @@ export class Exporter {
           },
         },
         sheets: {
-          sheet: source.sheet_data.map((sheet, index) => {
-            const a$: any = {
+          sheet: source.sheet_data.map((sheet, index) => ({
+            a$: {
               name: sheet.name || `Sheet${index + 1}`,
               sheetId: index + 1,
               'r:id': worksheet_rels_map[index],
-            };
-            if (sheet.visible === false) {
-              a$.state = 'hidden';
+              state: (sheet.visible === false) ? 'hidden' : undefined,
             }
-            return { a$ };
-          }),
+          })),
         },
         definedNames,
       },
@@ -2554,7 +2382,7 @@ export class Exporter {
       }
     }
 
-    const content_types_dom: any = {
+    const content_types_dom: DOMContent = {
       Types: {
         a$: {
           'xmlns': 'http://schemas.openxmlformats.org/package/2006/content-types',
@@ -2578,7 +2406,7 @@ export class Exporter {
           }),
 
           // charts and drawings
-          ...drawings.reduce((a: any, drawing) => {
+          ...drawings.reduce((a: DOMContent[], drawing) => {
             return a.concat([
               ...drawing.charts.map(chart => {
                 return { a$: {
@@ -2633,34 +2461,4 @@ export class Exporter {
     return new Blob([buffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
   }
 
-  /* * zip -> binary string * /
-  public async AsBinaryString(compression_level?: number) {
-    if (!this.zip) {
-      throw new Error('missing zip');
-    }
-    const opts: JSZip.JSZipGeneratorOptions = { type: 'binarystring' };
-    if (typeof compression_level !== 'undefined') {
-      opts.compression = 'DEFLATE';
-      opts.compressionOptions = {level: compression_level };
-    }
-    const output = await this.zip.generateAsync(opts);
-    return output;
-  }
-
-  /* * zip -> blob * /
-  public async AsBlob(compression_level?: number) {
-    if (!this.zip) {
-      throw new Error('missing zip');
-    }
-    const opts: JSZip.JSZipGeneratorOptions = { type: 'blob' };
-    if (typeof compression_level !== 'undefined') {
-      opts.compression = 'DEFLATE';
-      opts.compressionOptions = {level: compression_level };
-    }
-    const output = await this.zip.generateAsync(opts);
-    return output;
-  }
-  */
-
-
-}
+}