@trebco/treb 32.5.0 → 32.6.4

package/treb-export/src/metadata.ts

@@ -0,0 +1,187 @@
+import { XMLUtils } from './xml-utils';
+
+/**
+ * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.metadatarecord?view=openxml-3.0.1
+ * 
+ * ah, mixing 0-based and 1-based indexes. that's great. not at all confusing.
+ */
+export interface MetadataRecord  {
+
+  //
+  // A 1-based index to the metadata record type in metadataTypes.
+  //
+  t: number;
+
+  //
+  // A zero based index to a specific metadata record. If the corresponding 
+  // metadataType has name="XLMDX", then this is an index to a record in 
+  // mdxMetadata, otherwise this is an index to a record in the futureMetadata 
+  // section whose name matches the name of the metadataType.
+  //
+  v: number;
+
+}
+
+/** 
+ * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.metadatatype?view=openxml-3.0.1
+ * 
+ * punting on all these attributes for now, except the ones we specifically 
+ * want.
+ */
+export interface MetadataType {
+
+  //
+  // Represents the name of this particular metadata type. This name shall be 
+  // unique amongst all other metadataTypes.
+  //
+  name: string;
+
+  //
+  // A Boolean flag indicating whether metadata is cell metadata. True when 
+  // the metadata is cell metadata, false otherwise - in the false case it 
+  // is considered to be value metadata.
+  //
+  cell_meta?: boolean;
+
+}
+
+/**
+ * the type `Future Feature Data Storage Area` is not actually defined? not 
+ * sure. maybe it's just a standard extension type and I need to look that up?
+ * 
+ * for the time being we'll use a list of flags...
+ */
+export interface MetadataFlags {
+  'dynamic-array'?: boolean;
+}
+
+/**
+ * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.futuremetadata?view=openxml-3.0.1
+ * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.futuremetadatablock?view=openxml-3.0.1
+ * 
+ * these are named, matching the names in "MetadataType"; we'll use those
+ * as indexes, and not store them in the object.
+ * 
+ */
+export interface FutureMetadata {
+  flags: MetadataFlags;
+}
+
+/**
+ * we're just reflecting the actual data at this point, not simplifying 
+ * (although we should simplify). will require some lookups.
+ */
+export interface Metadata {
+  cell_metadata: MetadataRecord[];
+  metadata_types: MetadataType[];
+
+  // TODO
+  // value_metadata: MetadataRecord[];
+
+  future_metadata: Record<string, FutureMetadata[]>;
+
+}
+
+export const LookupMetadata = (source: Metadata, type: 'cell'|'value', index: number): FutureMetadata => {
+
+  if (type === 'cell') {
+
+    //
+    // the docs say "zero based", but this looks to be one based -- there's
+    // only one entry when we create a doc, but the cm index in cells is "1".
+    //
+    // https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.cell?view=openxml-3.0.1&redirectedfrom=MSDN
+    //
+
+    const metadata_type = source.cell_metadata[index - 1];
+
+    if (metadata_type) {
+      const record_type = source.metadata_types[metadata_type.t - 1]; // 1-based
+      if (record_type) {
+        if (record_type.name === 'XLMDX') {
+          // ...
+        }
+        else {
+          const future_metadata_list = source.future_metadata[record_type.name];
+          if (future_metadata_list) {
+            return future_metadata_list[metadata_type.v] || {}; // 0-based
+          }
+        }
+      }
+    }
+  }
+  else {
+    console.warn('value metadata not implemented')
+  }
+
+  return {flags: {}}; // null, essentially
+
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const ParseMetadataXML = (xml: any): Metadata => {
+
+  const metadata: Metadata = {
+    metadata_types: [],
+    cell_metadata: [],
+    future_metadata: {},
+  };
+
+  const metadata_types = XMLUtils.FindAll(xml, 'metadata/metadataTypes/metadataType');
+  for (const entry of metadata_types) {
+
+    const name: string = entry.a$?.name || '';
+    const value = entry.a$?.cellMeta;
+    const cell_meta: boolean = (value === '1' || value === 'true');
+
+    metadata.metadata_types.push({ 
+      name, cell_meta 
+    });
+
+  }
+
+  const future_metadata_blocks = XMLUtils.FindAll(xml, 'metadata/futureMetadata');
+  for (const entry of future_metadata_blocks) {
+
+    const name: string = entry.a$?.name || '';
+    if (name) {
+
+      const future_metadata_list: FutureMetadata[] = [];
+
+      // `extLst` entries can be inside of `bk` entries, but aparently not
+      // required? what's the case where they are _not_ in `bk` elements?
+      
+      for (const block of XMLUtils.FindAll(entry, 'bk')) {
+
+        const future_metadata: FutureMetadata = { flags: {} };
+
+        // I guess metadata attributes are elements? we'll probably 
+        // have to look them up individually
+
+        for (const child of XMLUtils.FindAll(block, 'extLst/ext/xda:dynamicArrayProperties')) {
+          if (child?.a$.fDynamic === '1') {
+            future_metadata.flags['dynamic-array'] = true;
+          }
+        }
+
+        future_metadata_list.push(future_metadata);
+
+      }
+
+      metadata.future_metadata[name] = future_metadata_list;
+
+    }
+  }
+
+  for (const entry of XMLUtils.FindAll(xml, 'metadata/cellMetadata/bk/rc')) {
+    metadata.cell_metadata.push({
+      t: Number(entry.a$?.t || -1),
+      v: Number(entry.a$?.v || -1),
+    });
+  }
+
+  // console.info({metadata});
+
+  return metadata;
+    
+}

package/treb-export/src/workbook.ts

@@ -38,6 +38,7 @@ import type { RelationshipMap } from './relationship';
 import { ZipWrapper } from './zip-wrapper';
 import type { CellStyle, ThemeColor } from 'treb-base-types';
 import type { SerializedNamed } from 'treb-data-model';
+import { type Metadata, ParseMetadataXML } from './metadata';
 
 /**
  * @privateRemarks -- FIXME: not sure about the equal/equals thing. need to check.
@@ -53,20 +54,42 @@ export const ConditionalFormatOperators: Record<string, string> = {
   notEqual: '<>',
 };
 
+//
+// enums? really? in 2025? FIXME
+//
 export enum ChartType {
-  Unknown = 0, Column, Bar, Line, Scatter, Donut, Pie, Bubble, Box
+  Null = 0, 
+  Column, 
+  Bar, 
+  Line, 
+  Scatter, 
+  Donut, 
+  Pie, 
+  Bubble, 
+  Box, 
+  Histogram, 
+  Unknown
 }
 
 export interface ChartSeries {
   values?: string;
   categories?: string;
   bubble_size?: string;
+
+  /** special for histogram */
+  bin_count?: number;
+
   title?: string;
 }
 
+type ChartFlags =
+  'stacked'
+  ;
+
 export interface ChartDescription {
   title?: string;
   type: ChartType; 
+  flags?: ChartFlags[];
   series?: ChartSeries[];
 }
 
@@ -151,6 +174,9 @@ export class Workbook {
   /** the workbook "rels" */
   public rels: RelationshipMap = {};
 
+  /** metadata reference; new and WIP */
+  public metadata?: Metadata;
+  
   public sheets: Sheet[] = [];
 
   public active_tab = 0;
@@ -200,6 +226,13 @@ export class Workbook {
     let xml = xmlparser2.parse(data || '');
     this.shared_strings.FromXML(xml);
 
+    // new(ish) metadata
+    if (this.zip.Has('xl/metadata.xml')) {
+      data = this.zip.Get('xl/metadata.xml');
+      xml = xmlparser2.parse(data);
+      this.metadata = ParseMetadataXML(xml);
+    }
+
     // theme
     data = this.zip.Get('xl/theme/theme1.xml');
     xml = xmlparser2.parse(data);
@@ -542,7 +575,7 @@ export class Workbook {
     const xml = xmlparser2.parse(data);
 
     const result: ChartDescription = {
-      type: ChartType.Unknown
+      type: ChartType.Null
     };
 
     // console.info("RC", xml);
@@ -562,8 +595,29 @@ export class Workbook {
         }
       }
       else {
+
+        // there's a bug in FindAll -- seems to have to do with the nodes
+        // here being strings
+
+        const nodes: (string | { t$: string })[] = [];
+        const parents = XMLUtils.FindAll(title_node, 'c:tx/c:rich/a:p/a:r');
+        for (const entry of parents) {
+          if (entry['a:t']) {
+            nodes.push(entry['a:t'])
+          }
+        }
+
+        /*
+        const xx = XMLUtils.FindAll(title_node, 'c:tx/c:rich/a:p/a:r');
+        const yy = XMLUtils.FindAll(title_node, 'c:tx/c:rich/a:p/a:r/a:t');
+        console.info({xx, yy});
+
         const nodes = XMLUtils.FindAll(title_node, 'c:tx/c:rich/a:p/a:r/a:t');
-        result.title = '"' + nodes.join('') + '"';
+        */
+
+        result.title = '"' + nodes.map(node => {
+          return typeof node === 'string' ? node : (node.t$ || '');
+        }).join('') + '"';
       }
 
     }
@@ -653,6 +707,14 @@ export class Workbook {
       if (node['c:barDir']) {
         if (node['c:barDir'].a$?.val === 'col') {
           result.type = ChartType.Column;
+
+          if (node['c:grouping']?.a$?.val === 'stacked') {
+            if (!result.flags) {
+              result.flags = [];
+            }
+            result.flags.push('stacked');
+          }
+
         }
       }
       
@@ -705,9 +767,92 @@ export class Workbook {
       // box plot uses "extended chart" which is totally different... but we 
       // might need it again later? for the time being it's just inlined
 
+      // hmmm also used for histogram... histograms aren't named, they are 
+      // clustered column type with a binning element, which has some attributes
+
       const ex_series = XMLUtils.FindAll(xml, 'cx:chartSpace/cx:chart/cx:plotArea/cx:plotAreaRegion/cx:series');
       if (ex_series?.length) {
-        if (ex_series.every(test => test.a$?.layoutId === 'boxWhisker')) {
+
+        // testing seems to require looping, so let's try to merge loops
+
+        let clustered_column = true;
+        let histogram = true;
+        let box_whisker = true;
+
+        for (const series of ex_series) {
+
+          const layout = series.a$?.layoutId;
+
+          if (clustered_column && layout !== 'clusteredColumn') {
+            clustered_column = false;
+          }
+          if (box_whisker && layout !== 'boxWhisker') {
+            box_whisker = false;
+          }
+          if (clustered_column && histogram) {
+            const binning = XMLUtils.FindAll(series, `cx:layoutPr/cx:binning`);
+            if (!binning.length) {
+              histogram = false;
+            }
+          }
+
+        }
+
+        // ok that's what we know so far...
+
+        if (histogram) {
+          result.type = ChartType.Histogram;
+          result.series = [];
+
+          for (const series_entry of ex_series) {
+
+            if (series_entry.a$?.hidden === '1') {
+              continue;
+            }
+            
+            const series: ChartSeries = {};
+
+            const data = XMLUtils.FindAll(xml, 'cx:chartSpace/cx:chartData/cx:data');
+
+            // so there are multiple series, and multiple datasets,
+            // but they are all merged together? no idea how this design
+            // works
+
+            const values_list: string[] = [];
+            for (const data_series of data) {
+              values_list.push(data_series['cx:numDim']?.['cx:f'] || '');
+            }
+            series.values = values_list.join(',');
+
+            const bin_count = XMLUtils.FindAll(series_entry, `cx:layoutPr/cx:binning/cx:binCount`);
+            if (bin_count[0]) {
+              const count = Number(bin_count[0].a$?.val || 0);
+              if (count) {
+                series.bin_count = count;
+              }
+            }
+
+            result.series.push(series);
+
+          }
+
+          const title = XMLUtils.FindAll(xml, 'cx:chartSpace/cx:chart/cx:title/cx:tx/cx:txData');
+          if (title) {
+            if (title[0]?.['cx:f']) {
+              result.title = title[0]['cx:f'];
+            }
+            else if (title[0]?.['cx:v']) {
+              result.title = '"' + title[0]['cx:v'] + '"';
+            }
+          }
+
+          console.info("histogram", result);
+          return result;
+          
+        }
+
+        if (box_whisker) {
+
           result.type = ChartType.Box;
           result.series = [];
           const data = XMLUtils.FindAll(xml, 'cx:chartSpace/cx:chartData/cx:data'); // /cx:data/cx:numDim/cx:f');
@@ -758,7 +903,8 @@ export class Workbook {
     }
 
     if (!node) {
-      console.info("Chart type not handled");
+      console.info("Chart type not handled", {xml});
+      result.type = ChartType.Unknown;
     }
 
     // console.info("RX?", result);