@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/ts/Spreadsheet/DataMapTable/DataMapHeader.js

@@ -0,0 +1,418 @@
+import { map, isEmpty, head, tail, tryFindIndex, item } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FsCell } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/Cells/FsCell.fs.js';
+import { value, map as map$1, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { OntologyAnnotation } from '../../Core/OntologyAnnotation.js';
+import { Data } from '../../Core/Data.js';
+import { DataContext__set_Explication_279AAFF2, DataContext__set_Unit_279AAFF2, DataContext__set_ObjectType_279AAFF2, DataContext__set_Description_6DFDD678, DataContext__set_GeneratedBy_6DFDD678, DataContext__set_Label_6DFDD678 } from '../../Core/DataContext.js';
+import { Option_fromValueWithDefault } from '../../Core/Helper/Collections.js';
+import { Comment$ } from '../../Core/Comment.js';
+import { ActivePatterns_$007CComment$007C_$007C } from '../../Core/Helper/Regex.js';
+import { join, toFail, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { toList, delay, append, map as map$2 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+function ActivePattern_ontologyAnnotationFromFsCells(tsrCol, tanCol, cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  const tsr = map$1((i) => item(i, cellValues), tsrCol);
+  const tan = map$1((i_1) => item(i_1, cellValues), tanCol);
+  return new OntologyAnnotation(item(0, cellValues), unwrap(tsr), unwrap(tan));
+}
+function ActivePattern_freeTextFromFsCells(cells) {
+  return item(0, map((c) => c.ValueAsString(), cells));
+}
+function ActivePattern_dataFromFsCells(format, selectorFormat, cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  const format_1 = map$1((i) => item(i, cellValues), format);
+  const selectorFormat_1 = map$1((i_1) => item(i_1, cellValues), selectorFormat);
+  return new Data(void 0, item(0, cellValues), void 0, unwrap(format_1), unwrap(selectorFormat_1));
+}
+function ActivePattern_$007CTerm$007C_$007C(categoryString, cells) {
+  const $007CAC$007C_$007C = (s) => {
+    if (s === categoryString) {
+      return 1;
+    } else {
+      return void 0;
+    }
+  };
+  const $007CTSRColumnHeaderRaw$007C_$007C = (s_1) => {
+    if (s_1.startsWith("Term Source REF")) {
+      return s_1;
+    } else {
+      return void 0;
+    }
+  };
+  const $007CTANColumnHeaderRaw$007C_$007C = (s_2) => {
+    if (s_2.startsWith("Term Accession Number")) {
+      return s_2;
+    } else {
+      return void 0;
+    }
+  };
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult;
+  if (!isEmpty(cellValues)) {
+    const activePatternResult = $007CAC$007C_$007C(head(cellValues));
+    if (activePatternResult != null) {
+      if (isEmpty(tail(cellValues))) {
+        matchResult = 0;
+        value(activePatternResult);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (cells_1) => ActivePattern_ontologyAnnotationFromFsCells(void 0, void 0, cells_1);
+    default: {
+      let matchResult_1;
+      if (!isEmpty(cellValues)) {
+        const activePatternResult_1 = $007CAC$007C_$007C(head(cellValues));
+        if (activePatternResult_1 != null) {
+          if (!isEmpty(tail(cellValues))) {
+            if ($007CTSRColumnHeaderRaw$007C_$007C(head(tail(cellValues))) != null) {
+              if (!isEmpty(tail(tail(cellValues)))) {
+                if ($007CTANColumnHeaderRaw$007C_$007C(head(tail(tail(cellValues)))) != null) {
+                  if (isEmpty(tail(tail(tail(cellValues))))) {
+                    matchResult_1 = 0;
+                    value(activePatternResult_1);
+                  } else {
+                    matchResult_1 = 1;
+                  }
+                } else {
+                  matchResult_1 = 1;
+                }
+              } else {
+                matchResult_1 = 1;
+              }
+            } else {
+              matchResult_1 = 1;
+            }
+          } else {
+            matchResult_1 = 1;
+          }
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+      switch (matchResult_1) {
+        case 0:
+          return (cells_2) => ActivePattern_ontologyAnnotationFromFsCells(1, 2, cells_2);
+        default: {
+          let matchResult_2;
+          if (!isEmpty(cellValues)) {
+            const activePatternResult_4 = $007CAC$007C_$007C(head(cellValues));
+            if (activePatternResult_4 != null) {
+              if (!isEmpty(tail(cellValues))) {
+                if ($007CTANColumnHeaderRaw$007C_$007C(head(tail(cellValues))) != null) {
+                  if (!isEmpty(tail(tail(cellValues)))) {
+                    if ($007CTSRColumnHeaderRaw$007C_$007C(head(tail(tail(cellValues)))) != null) {
+                      if (isEmpty(tail(tail(tail(cellValues))))) {
+                        matchResult_2 = 0;
+                        value(activePatternResult_4);
+                      } else {
+                        matchResult_2 = 1;
+                      }
+                    } else {
+                      matchResult_2 = 1;
+                    }
+                  } else {
+                    matchResult_2 = 1;
+                  }
+                } else {
+                  matchResult_2 = 1;
+                }
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+          } else {
+            matchResult_2 = 1;
+          }
+          switch (matchResult_2) {
+            case 0:
+              return (cells_3) => ActivePattern_ontologyAnnotationFromFsCells(2, 1, cells_3);
+            default:
+              return void 0;
+          }
+        }
+      }
+    }
+  }
+}
+function ActivePattern_$007CExplication$007C_$007C(cells) {
+  const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Explication", cells);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return (dc) => (cells_1) => {
+      DataContext__set_Explication_279AAFF2(dc, r(cells_1));
+      return dc;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ActivePattern_$007CUnit$007C_$007C(cells) {
+  const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Unit", cells);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return (dc) => (cells_1) => {
+      DataContext__set_Unit_279AAFF2(dc, r(cells_1));
+      return dc;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ActivePattern_$007CObjectType$007C_$007C(cells) {
+  const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Object Type", cells);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return (dc) => (cells_1) => {
+      DataContext__set_ObjectType_279AAFF2(dc, r(cells_1));
+      return dc;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ActivePattern_$007CDescription$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult;
+  if (!isEmpty(cellValues)) {
+    if (head(cellValues) === "Description") {
+      if (isEmpty(tail(cellValues))) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        DataContext__set_Description_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function ActivePattern_$007CGeneratedBy$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult;
+  if (!isEmpty(cellValues)) {
+    if (head(cellValues) === "Generated By") {
+      if (isEmpty(tail(cellValues))) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        DataContext__set_GeneratedBy_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function ActivePattern_$007CLabel$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult;
+  if (!isEmpty(cellValues)) {
+    if (head(cellValues) === "Label") {
+      if (isEmpty(tail(cellValues))) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        DataContext__set_Label_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function ActivePattern_$007CData$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult, cols;
+  if (!isEmpty(cellValues)) {
+    if (head(cellValues) === "Data") {
+      matchResult = 0;
+      cols = tail(cellValues);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        const d = ActivePattern_dataFromFsCells(map$1((y) => 1 + y, tryFindIndex((s) => s.startsWith("Data Format"), cols)), map$1((y_1) => 1 + y_1, tryFindIndex((s_1) => s_1.startsWith("Data Selector Format"), cols)), cells_1);
+        dc.FilePath = d.FilePath;
+        dc.Selector = d.Selector;
+        dc.Format = d.Format;
+        dc.SelectorFormat = d.SelectorFormat;
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function ActivePattern_$007CComment$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult, key;
+  if (!isEmpty(cellValues)) {
+    const activePatternResult = ActivePatterns_$007CComment$007C_$007C(head(cellValues));
+    if (activePatternResult != null) {
+      if (isEmpty(tail(cellValues))) {
+        matchResult = 0;
+        key = value(activePatternResult);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        const comment = item(0, map((c_1) => c_1.ValueAsString(), cells_1));
+        void dc.Comments.push(Comment$.create(key, comment));
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function ActivePattern_$007CFreetext$007C_$007C(cells) {
+  const cellValues = map((c) => c.ValueAsString(), cells);
+  let matchResult, key;
+  if (!isEmpty(cellValues)) {
+    if (isEmpty(tail(cellValues))) {
+      matchResult = 0;
+      key = head(cellValues);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => {
+        const comment = item(0, map((c_1) => c_1.ValueAsString(), cells_1));
+        void dc.Comments.push(Comment$.create(key, comment));
+        return dc;
+      };
+    default:
+      return void 0;
+  }
+}
+function fromFsCells(cells) {
+  let matchResult, r;
+  const activePatternResult = ActivePattern_$007CExplication$007C_$007C(cells);
+  if (activePatternResult != null) {
+    matchResult = 0;
+    r = value(activePatternResult);
+  } else {
+    const activePatternResult_1 = ActivePattern_$007CUnit$007C_$007C(cells);
+    if (activePatternResult_1 != null) {
+      matchResult = 0;
+      r = value(activePatternResult_1);
+    } else {
+      const activePatternResult_2 = ActivePattern_$007CObjectType$007C_$007C(cells);
+      if (activePatternResult_2 != null) {
+        matchResult = 0;
+        r = value(activePatternResult_2);
+      } else {
+        const activePatternResult_3 = ActivePattern_$007CDescription$007C_$007C(cells);
+        if (activePatternResult_3 != null) {
+          matchResult = 0;
+          r = value(activePatternResult_3);
+        } else {
+          const activePatternResult_4 = ActivePattern_$007CGeneratedBy$007C_$007C(cells);
+          if (activePatternResult_4 != null) {
+            matchResult = 0;
+            r = value(activePatternResult_4);
+          } else {
+            const activePatternResult_5 = ActivePattern_$007CLabel$007C_$007C(cells);
+            if (activePatternResult_5 != null) {
+              matchResult = 0;
+              r = value(activePatternResult_5);
+            } else {
+              const activePatternResult_6 = ActivePattern_$007CData$007C_$007C(cells);
+              if (activePatternResult_6 != null) {
+                matchResult = 0;
+                r = value(activePatternResult_6);
+              } else {
+                const activePatternResult_7 = ActivePattern_$007CComment$007C_$007C(cells);
+                if (activePatternResult_7 != null) {
+                  matchResult = 0;
+                  r = value(activePatternResult_7);
+                } else {
+                  const activePatternResult_8 = ActivePattern_$007CFreetext$007C_$007C(cells);
+                  if (activePatternResult_8 != null) {
+                    matchResult = 0;
+                    r = value(activePatternResult_8);
+                  } else {
+                    matchResult = 1;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  switch (matchResult) {
+    case 0:
+      return (dc) => (cells_1) => r(dc)(cells_1);
+    default: {
+      const arg = join(", ", map((c) => c.ValueAsString(), cells));
+      const clo_1 = toFail(printf("Could not parse data map column: %s"))(arg);
+      return (arg_1) => {
+        const clo_2 = clo_1(arg_1);
+        return clo_2;
+      };
+    }
+  }
+}
+function toFsCells(commentKeys) {
+  return toList(delay(() => append([new FsCell("Data"), new FsCell("Data Format"), new FsCell("Data Selector Format")], delay(() => append([new FsCell("Explication"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Unit"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Object Type"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Description")], delay(() => append([new FsCell("Generated By")], delay(() => append([new FsCell("Label")], delay(() => map$2((ck) => new FsCell(`Comment [${ck}]`), commentKeys)))))))))))))))));
+}
+
+export { ActivePattern_$007CComment$007C_$007C, ActivePattern_$007CData$007C_$007C, ActivePattern_$007CDescription$007C_$007C, ActivePattern_$007CExplication$007C_$007C, ActivePattern_$007CFreetext$007C_$007C, ActivePattern_$007CGeneratedBy$007C_$007C, ActivePattern_$007CLabel$007C_$007C, ActivePattern_$007CObjectType$007C_$007C, ActivePattern_$007CTerm$007C_$007C, ActivePattern_$007CUnit$007C_$007C, ActivePattern_dataFromFsCells, ActivePattern_freeTextFromFsCells, ActivePattern_ontologyAnnotationFromFsCells, fromFsCells, toFsCells };

package/dist/ts/ts/Spreadsheet/DataMapTable/DataMapTable.d.ts

@@ -1,7 +1,7 @@
 import { FSharpList } from '@fable-org/fable-library-js/List.js';
-import { FsColumn } from '../../fable_modules/FsSpreadsheet.6.3.1/FsColumn.fs.js';
-import { FsTable } from '../../fable_modules/FsSpreadsheet.6.3.1/Tables/FsTable.fs.js';
-import { FsWorksheet } from '../../fable_modules/FsSpreadsheet.6.3.1/FsWorksheet.fs.js';
+import { FsColumn } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/FsColumn.fs.js';
+import { FsTable } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/Tables/FsTable.fs.js';
+import { FsWorksheet } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/FsWorksheet.fs.js';
 import { Option } from '@fable-org/fable-library-js/Option.js';
 import { DataContext } from '../../Core/DataContext.js';
 import { DataMap } from '../../Core/DataMap.js';

package/dist/ts/ts/Spreadsheet/DataMapTable/DataMapTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataMapTable.d.ts","sourceRoot":"","sources":["../../../../../src/ARCtrl/ts/Spreadsheet/DataMapTable/DataMapTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,UAAU,EAAW,MAAM,qCAAqC,CAAC;AAEzH,OAAO,EAAE,QAAQ,EAAE,MAAM,wDAAwD,CAAC;AAElF,OAAO,EAAE,OAAO,EAAE,MAAM,8DAA8D,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,2DAA2D,CAAC;AACxF,OAAO,EAAoB,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAEjF,OAAO,EAAE,WAAW,EAA+B,MAAM,2BAA2B,CAAC;AAIrF,OAAO,EAA6B,OAAO,EAA0B,MAAM,uBAAuB,CAAC;AASnG,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC,MAAM,CAAgG,CAAC;AAEpJ,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAKpG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAEnE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,WAAW,EAAE,CAOzE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAgBtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAqCzD"}
+{"version":3,"file":"DataMapTable.d.ts","sourceRoot":"","sources":["../../../../../src/ARCtrl/ts/Spreadsheet/DataMapTable/DataMapTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,UAAU,EAAW,MAAM,qCAAqC,CAAC;AAEzH,OAAO,EAAE,QAAQ,EAAE,MAAM,gEAAgE,CAAC;AAE1F,OAAO,EAAE,OAAO,EAAE,MAAM,sEAAsE,CAAC;AAC/F,OAAO,EAAE,WAAW,EAAE,MAAM,mEAAmE,CAAC;AAChG,OAAO,EAAoB,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAEjF,OAAO,EAAE,WAAW,EAA+B,MAAM,2BAA2B,CAAC;AAIrF,OAAO,EAA6B,OAAO,EAA0B,MAAM,uBAAuB,CAAC;AAQnG,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC,MAAM,CAAgG,CAAC;AAEpJ,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAKpG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAEnE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,WAAW,EAAE,CAOzE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAgBtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAqCzD"}

package/dist/ts/ts/Spreadsheet/DataMapTable/DataMapTable.js

@@ -0,0 +1,85 @@
+import { ofArray, length, head, iterateIndexed, iterate, exists } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { Aux_List_groupWhen } from '../AnnotationTable/ArcTable.js';
+import { tryFind, item, toArray, delay, toList, map } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsWorksheet } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/FsWorksheet.fs.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { DataContext_$ctor_Z780A8A2A } from '../../Core/DataContext.js';
+import { rangeDouble } from '../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { toFsColumns, setFromFsColumns } from './DataMapColumn.js';
+import { toFail, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { DataMap__get_DataContexts, DataMap_$ctor_4E3220A7 } from '../../Core/DataMap.js';
+import { FsRangeAddress } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/FsAddress.fs.js';
+import { Dictionary_tryGet } from '../../fable_modules/FsSpreadsheet.7.0.0-alpha.1/Cells/FsCellsCollection.fs.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+
+const helperColumnStrings = ofArray(["Term Source REF", "Term Accession Number", "Data Format", "Data Selector Format"]);
+function groupColumnsByHeader(columns) {
+  return Aux_List_groupWhen((c) => {
+    const v = c.Item(1).ValueAsString();
+    return !exists((s) => v.startsWith(s), helperColumnStrings);
+  }, columns);
+}
+function tryDataMapTable(sheet) {
+  return tryFind((t) => t.Name.startsWith("datamapTable"), sheet.Tables);
+}
+function composeColumns(columns) {
+  const l = item(0, columns).MaxRowIndex - 1 | 0;
+  const dc = Array.from(toArray(delay(() => map((i) => DataContext_$ctor_Z780A8A2A(), rangeDouble(0, 1, l - 1)))));
+  iterate((arg) => {
+    setFromFsColumns(dc, arg);
+  }, groupColumnsByHeader(toList(columns)));
+  return dc;
+}
+function tryFromFsWorksheet(sheet) {
+  try {
+    const matchValue = tryDataMapTable(sheet);
+    if (matchValue == null) {
+      return void 0;
+    } else {
+      const t = value(matchValue);
+      return DataMap_$ctor_4E3220A7(composeColumns(t.GetColumns(sheet.CellCollection)));
+    }
+  } catch (err) {
+    const arg = sheet.Name;
+    const arg_1 = err.message;
+    return toFail(printf('Could not parse datamap table with name "%s":\n%s'))(arg)(arg_1);
+  }
+}
+function toFsWorksheet(table) {
+  const stringCount = /* @__PURE__ */ new Map([]);
+  const ws = new FsWorksheet("isa_datamap");
+  if (DataMap__get_DataContexts(table).length === 0) {
+    return ws;
+  } else {
+    const columns = toFsColumns(DataMap__get_DataContexts(table));
+    const maxRow = length(head(columns)) | 0;
+    const maxCol = length(columns) | 0;
+    const fsTable = ws.Table("datamapTable", new FsRangeAddress(new FsAddress(1, 1), new FsAddress(maxRow, maxCol)));
+    iterateIndexed((colI, col) => {
+      iterateIndexed((rowI, cell) => {
+        let value$1;
+        const v = cell.ValueAsString();
+        if (rowI === 0) {
+          const matchValue = Dictionary_tryGet(v, stringCount);
+          if (matchValue == null) {
+            addToDict(stringCount, cell.ValueAsString(), "");
+            value$1 = v;
+          } else {
+            const spaces = value(matchValue);
+            stringCount.set(v, spaces + " ");
+            value$1 = v + " " + spaces;
+          }
+        } else {
+          value$1 = v;
+        }
+        const address = new FsAddress(rowI + 1, colI + 1);
+        fsTable.Cell(address, ws.CellCollection).SetValueAs(value$1);
+      }, col);
+    }, columns);
+    ws.RescanRows();
+    return ws;
+  }
+}
+
+export { composeColumns, groupColumnsByHeader, helperColumnStrings, toFsWorksheet, tryDataMapTable, tryFromFsWorksheet };

package/dist/ts/ts/Spreadsheet/Metadata/Assays.js

@@ -0,0 +1,90 @@
+import { ofArray, length, singleton, initialize, map, empty, iterateIndexed, cons, reverse } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { OntologyAnnotation } from '../../Core/OntologyAnnotation.js';
+import { unwrap, value, map as map$1, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { createMissingIdentifier, Assay_tryIdentifierFromFileName, removeMissingIdentifier, Assay_fileNameFromIdentifier } from '../../Core/Helper/Identifier.js';
+import { Option_fromValueWithDefault, ResizeArray_iter } from '../../Core/Helper/Collections.js';
+import { JsonTypes_decomposeTechnologyPlatform, JsonTypes_composeTechnologyPlatform } from '../../Core/Conversion.js';
+import { ArcAssay } from '../../Core/ArcTypes.js';
+import { SparseTable_FromRows_Z5579EC29, SparseTable_GetEmptyComments_3ECCA699, SparseTable__TryGetValueDefault_5BAE6133, SparseTable__TryGetValue_11FD62A8, SparseTable_ToRows_759CAFC1, SparseTable_Create_Z2192E64B, SparseTable } from './SparseTable.js';
+import { Comment_fromString, Comment_toString } from './Comment.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { List_distinct } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { stringHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+
+const labels = ofArray(["Identifier", "Title", "Description", "Measurement Type", "Measurement Type Term Accession Number", "Measurement Type Term Source REF", "Technology Type", "Technology Type Term Accession Number", "Technology Type Term Source REF", "Technology Platform", "File Name"]);
+function fromString(identifier, title, description, measurementType, measurementTypeTermSourceREF, measurementTypeTermAccessionNumber, technologyType, technologyTypeTermSourceREF, technologyTypeTermAccessionNumber, technologyPlatform, fileName, comments) {
+  const measurementType_1 = OntologyAnnotation.create(unwrap(measurementType), unwrap(measurementTypeTermSourceREF), unwrap(measurementTypeTermAccessionNumber));
+  const technologyType_1 = OntologyAnnotation.create(unwrap(technologyType), unwrap(technologyTypeTermSourceREF), unwrap(technologyTypeTermAccessionNumber));
+  let identifier_4;
+  if (identifier == null) {
+    if (fileName == null) {
+      identifier_4 = createMissingIdentifier();
+    } else {
+      const matchValue = Assay_tryIdentifierFromFileName(value(fileName));
+      identifier_4 = matchValue != null ? value(matchValue) : createMissingIdentifier();
+    }
+  } else {
+    identifier_4 = value(identifier);
+  }
+  const measurementType_2 = Option_fromValueWithDefault(new OntologyAnnotation(), measurementType_1);
+  const technologyType_2 = Option_fromValueWithDefault(new OntologyAnnotation(), technologyType_1);
+  const technologyPlatform_1 = map$1(JsonTypes_decomposeTechnologyPlatform, technologyPlatform);
+  return ArcAssay.make(identifier_4, title, description, measurementType_2, technologyType_2, technologyPlatform_1, [], void 0, [], comments);
+}
+function fromSparseTable(matrix) {
+  if (matrix.ColumnCount === 0 && length(matrix.CommentKeys) !== 0) {
+    const comments = SparseTable_GetEmptyComments_3ECCA699(matrix);
+    return singleton(ArcAssay.create(createMissingIdentifier(), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, comments));
+  } else {
+    return initialize(matrix.ColumnCount, (i) => {
+      let comments_1;
+      const collection = map((k) => Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", [k, i])), matrix.CommentKeys);
+      comments_1 = Array.from(collection);
+      return fromString(SparseTable__TryGetValue_11FD62A8(matrix, ["Identifier", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Title", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Description", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type Term Source REF", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type Term Accession Number", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type Term Source REF", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type Term Accession Number", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Platform", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["File Name", i]), comments_1);
+    });
+  }
+}
+function toSparseTable(assays) {
+  const matrix = SparseTable_Create_Z2192E64B(void 0, labels, void 0, length(assays) + 1);
+  let commentKeys = empty();
+  iterateIndexed((i, a) => {
+    const processedFileName = a.Identifier.startsWith("MISSING_IDENTIFIER_") ? removeMissingIdentifier(a.Identifier) : Assay_fileNameFromIdentifier(a.Identifier);
+    const i_1 = i + 1 | 0;
+    let mt_1;
+    const mt = defaultArg(a.MeasurementType, new OntologyAnnotation());
+    mt_1 = OntologyAnnotation.toStringObject(mt, true);
+    let tt_1;
+    const tt = defaultArg(a.TechnologyType, new OntologyAnnotation());
+    tt_1 = OntologyAnnotation.toStringObject(tt, true);
+    addToDict(matrix.Matrix, ["Identifier", i_1], removeMissingIdentifier(a.Identifier));
+    addToDict(matrix.Matrix, ["Title", i_1], defaultArg(a.Title, ""));
+    addToDict(matrix.Matrix, ["Description", i_1], defaultArg(a.Description, ""));
+    addToDict(matrix.Matrix, ["Measurement Type", i_1], mt_1.TermName);
+    addToDict(matrix.Matrix, ["Measurement Type Term Accession Number", i_1], mt_1.TermAccessionNumber);
+    addToDict(matrix.Matrix, ["Measurement Type Term Source REF", i_1], mt_1.TermSourceREF);
+    addToDict(matrix.Matrix, ["Technology Type", i_1], tt_1.TermName);
+    addToDict(matrix.Matrix, ["Technology Type Term Accession Number", i_1], tt_1.TermAccessionNumber);
+    addToDict(matrix.Matrix, ["Technology Type Term Source REF", i_1], tt_1.TermSourceREF);
+    addToDict(matrix.Matrix, ["Technology Platform", i_1], defaultArg(map$1(JsonTypes_composeTechnologyPlatform, a.TechnologyPlatform), ""));
+    addToDict(matrix.Matrix, ["File Name", i_1], processedFileName);
+    ResizeArray_iter((comment) => {
+      const patternInput = Comment_toString(comment);
+      const n = patternInput[0];
+      commentKeys = cons(n, commentKeys);
+      addToDict(matrix.Matrix, [n, i_1], patternInput[1]);
+    }, a.Comments);
+  }, assays);
+  return new SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(commentKeys, {
+    Equals: (x, y) => x === y,
+    GetHashCode: stringHash
+  })), matrix.ColumnCount);
+}
+function fromRows(prefix, lineNumber, rows) {
+  const tupledArg = SparseTable_FromRows_Z5579EC29(rows, labels, lineNumber, unwrap(prefix));
+  return [tupledArg[0], tupledArg[1], tupledArg[2], fromSparseTable(tupledArg[3])];
+}
+function toRows(prefix, assays) {
+  return SparseTable_ToRows_759CAFC1(toSparseTable(assays), unwrap(prefix));
+}
+
+export { fromRows, fromSparseTable, fromString, labels, toRows, toSparseTable };

package/dist/ts/ts/Spreadsheet/Metadata/Comment.js

@@ -0,0 +1,58 @@
+import { ActivePatterns_$007CRegex$007C_$007C } from '../../Core/Helper/Regex.js';
+import { value, bind, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { Option_fromValueWithDefault } from './Conversions.js';
+import { Comment$ } from '../../Core/Comment.js';
+
+const Comment_commentValueKey = "commentValue";
+const Comment_commentPattern = `Comment\\s*\\[<(?<${Comment_commentValueKey}>.+)>\\]`;
+const Comment_commentPatternNoAngleBrackets = `Comment\\s*\\[(?<${Comment_commentValueKey}>.+)\\]`;
+function Comment_$007CComment$007C_$007C(key) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C(Comment_commentPattern, key);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return r.groups && r.groups[Comment_commentValueKey] || "";
+  } else {
+    const activePatternResult_1 = ActivePatterns_$007CRegex$007C_$007C(Comment_commentPatternNoAngleBrackets, key);
+    if (activePatternResult_1 != null) {
+      const r_1 = value(activePatternResult_1);
+      const v = r_1.groups && r_1.groups[Comment_commentValueKey] || "";
+      if (v === "<>") {
+        return void 0;
+      } else {
+        return v;
+      }
+    } else {
+      return void 0;
+    }
+  }
+}
+function Comment_wrapCommentKey(k) {
+  return toText(printf("Comment[%s]"))(k);
+}
+function Comment_fromString(k, v) {
+  const name = Option_fromValueWithDefault("", k);
+  const value = Option_fromValueWithDefault("", v);
+  return Comment$.make(name, value);
+}
+function Comment_toString(c) {
+  return [defaultArg(c.Name, ""), defaultArg(c.Value, "")];
+}
+const Remark_remarkValueKey = "remarkValue";
+const Remark_remarkPattern = `#(?<${Remark_remarkValueKey}>.+)`;
+function Remark_$007CRemark$007C_$007C(key) {
+  return bind((k) => {
+    const activePatternResult = ActivePatterns_$007CRegex$007C_$007C(Remark_remarkPattern, k);
+    if (activePatternResult != null) {
+      const r = value(activePatternResult);
+      return r.groups && r.groups[Remark_remarkValueKey] || "";
+    } else {
+      return void 0;
+    }
+  }, key);
+}
+function Remark_wrapRemark(r) {
+  return toText(printf("#%s"))(r);
+}
+
+export { Comment_$007CComment$007C_$007C, Comment_commentPattern, Comment_commentPatternNoAngleBrackets, Comment_commentValueKey, Comment_fromString, Comment_toString, Comment_wrapCommentKey, Remark_$007CRemark$007C_$007C, Remark_remarkPattern, Remark_remarkValueKey, Remark_wrapRemark };