abstract-sheet 0.0.2

package/src/abstract-sheet-exporters/_xlsx-sheet.ts

@@ -0,0 +1,156 @@
+import * as XLSX from "xlsx-js-style";
+import { Style, CellType, Sheet } from "../abstract-sheet/abstract-sheet";
+
+export function xlsxWorkSheet(s: Sheet, styles: Record<string, any>): XLSX.WorkSheet {
+  let colMax = -1;
+  const cells: Record<string, XLSX.CellObject> = {};
+  for (let ri = 0; ri < s.rows.length; ri++) {
+    const r = s.rows[ri]!;
+    colMax = Math.max(r.length, colMax);
+    for (let ci = 0; ci < r.length; ci++) {
+      const c = r[ci]!;
+      let s: Object | undefined = undefined;
+      if (c.styles !== undefined) {
+        for (const style of c.styles) {
+          s = { ...s!, ...styles[style] };
+        }
+      }
+      cells[`${XLSX.utils.encode_col(ci)}${ri + 1}`] = { v: c.value, t: columnType(c.type), s };
+    }
+  }
+
+  return {
+    "!type": "sheet",
+    "!ref": `A1:${XLSX.utils.encode_col(colMax)}${s.rows.length}`,
+    "!cols": s.colInfo?.map((i): XLSX.ColInfo => ({ wpx: i.widthPixels, hidden: i.hidden })),
+    "!rows": s.rowInfo?.map((i): XLSX.RowInfo => ({ hpx: i.heightPixels, hidden: i.hidden })),
+    ...cells,
+  };
+}
+
+const columnType = (colType: CellType | undefined): XLSX.CellObject["t"] => {
+  switch (colType) {
+    case "number":
+      return "n";
+    case undefined:
+    case "string":
+      return "s";
+    default:
+      exhaustiveCheck(colType);
+      return "s";
+  }
+};
+
+const exhaustiveCheck = (check: never): never => check;
+
+export function createStyle(style: Style): any {
+  let s: any = {};
+  if (style.vertical || style.horizontal || style.wrapText !== undefined || style.textRotation !== undefined) {
+    s.alignment = {};
+    if (style.vertical) {
+      s.alignment.vertical = style.vertical;
+    }
+    if (style.horizontal) {
+      s.alignment.horizontal = style.horizontal;
+    }
+    if (style.wrapText !== undefined) {
+      s.alignment.wrapText = style.wrapText;
+    }
+    if (style.textRotation !== undefined) {
+      s.alignment.textRotation = style.textRotation;
+    }
+  }
+  if (style.fillType || style.foreground || style.background) {
+    s.fill = {};
+    if (style.fillType) {
+      s.fill.patternType = style.fillType;
+    }
+    if (style.foreground) {
+      s.fill.fgColor = { rgb: style.foreground };
+    }
+    if (style.background) {
+      s.fill.bgColor = { rgb: style.background };
+    }
+  }
+
+  if (style.borderStyle || style.borderColor) {
+    s.border = {};
+    if (style.borderStyle?.top || style.borderColor?.top) {
+      s.border.top = {};
+    }
+    if (style.borderStyle?.top) {
+      s.border.top.style = style.borderStyle.top;
+    }
+    if (style.borderColor?.top) {
+      s.border.top.color = { rgb: style.borderColor.top };
+    }
+    if (style.borderStyle?.right || style.borderColor?.right) {
+      s.border.right = {};
+    }
+    if (style.borderStyle?.right) {
+      s.border.right.style = style.borderStyle.right;
+    }
+    if (style.borderColor?.right) {
+      s.border.right.color = { rgb: style.borderColor.right };
+    }
+    if (style.borderStyle?.bottom || style.borderColor?.bottom) {
+      s.border.bottom = {};
+    }
+    if (style.borderStyle?.bottom) {
+      s.border.bottom.style = style.borderStyle.bottom;
+    }
+    if (style.borderColor?.bottom) {
+      s.border.bottom.color = { rgb: style.borderColor.bottom };
+    }
+    if (style.borderStyle?.left || style.borderColor?.left) {
+      s.border.left = {};
+    }
+    if (style.borderStyle?.left) {
+      s.border.left.style = style.borderStyle.left;
+    }
+    if (style.borderColor?.left) {
+      s.border.left.color = { rgb: style.borderColor.left };
+    }
+  }
+
+  if (
+    style.bold !== undefined ||
+    style.color ||
+    style.italic !== undefined ||
+    style.font ||
+    style.strike !== undefined ||
+    style.size !== undefined ||
+    style.underline !== undefined ||
+    style.script
+  ) {
+    s.font = {};
+    if (style.bold !== undefined) {
+      s.font.bold = style.bold;
+    }
+    if (style.color) {
+      s.font.color = { rgb: style.color };
+    }
+    if (style.italic !== undefined) {
+      s.font.italic = style.italic;
+    }
+    if (style.font) {
+      s.font.name = style.font;
+    }
+    if (style.strike !== undefined) {
+      s.font.strike = style.strike;
+    }
+    if (style.size !== undefined) {
+      s.font.sz = style.size;
+    }
+    if (style.underline !== undefined) {
+      s.font.underline = style.underline;
+    }
+    if (style.script !== undefined) {
+      s.font.vertAlign = style.script;
+    }
+  }
+  if (style.numberFormat !== undefined) {
+    s.font.numFmt = style.numberFormat;
+  }
+  return s;
+}

package/src/abstract-sheet-exporters/csv.ts

@@ -0,0 +1,36 @@
+import * as XLSX from "xlsx-js-style";
+import { AbstractSheet } from "../abstract-sheet/abstract-sheet";
+import { createStyle, xlsxWorkSheet } from "./_xlsx-sheet";
+
+export type CsvFile = { readonly name: string; readonly csv: string };
+
+export function toCsv(
+  as: AbstractSheet,
+  options?: {
+    readonly separator?: string;
+    readonly rowSeparator?: string;
+    readonly noTrailingSeparator?: boolean;
+    readonly blankRows?: boolean;
+    readonly skipHidden?: boolean;
+    readonly forceQuotes?: boolean;
+    readonly rawNumber?: boolean;
+    readonly dateFormat?: string;
+  }
+): ReadonlyArray<CsvFile> {
+  const styles = Object.fromEntries(as.styles?.map((s) => [s.name, createStyle(s)]) ?? []);
+  const mappedOptions: XLSX.Sheet2CSVOpts | undefined = options
+    ? {
+        FS: options.separator,
+        RS: options.rowSeparator,
+        strip: options.noTrailingSeparator,
+        blankrows: options.blankRows,
+        skipHidden: options.skipHidden,
+        forceQuotes: options.forceQuotes,
+        rawNumbers: options.rawNumber,
+        dateNF: options.dateFormat,
+      }
+    : undefined;
+  return as.sheets.map(
+    (s): CsvFile => ({ name: s.name, csv: XLSX.utils.sheet_to_csv(xlsxWorkSheet(s, styles), mappedOptions) })
+  );
+}

package/src/abstract-sheet-exporters/index.ts

@@ -0,0 +1,2 @@
+export * from "./csv";
+export * from "./xlsx";

package/src/abstract-sheet-exporters/xlsx.ts

@@ -0,0 +1,15 @@
+import * as XLSX from "xlsx-js-style";
+import { AbstractSheet } from "../abstract-sheet/abstract-sheet";
+import { createStyle, xlsxWorkSheet } from "./_xlsx-sheet";
+
+export function toXlsx(as: AbstractSheet): Buffer {
+  const sheets: Record<string, XLSX.WorkSheet> = {};
+  const sheetNames = Array<string>();
+  const styles = Object.fromEntries(as.styles?.map((s) => [s.name, createStyle(s)]) ?? []);
+  for (const s of as.sheets) {
+    sheetNames.push(s.name);
+    sheets[s.name] = xlsxWorkSheet(s, styles);
+  }
+  const wb: XLSX.WorkBook = { Sheets: sheets, SheetNames: Object.keys(sheets) };
+  return XLSX.write(wb, { bookType: "xlsx", bookSST: false, type: "buffer" });
+}

package/src/abstract-sheet-xml/abstract-sheet-xml.ts

@@ -0,0 +1,128 @@
+import {
+  borderStyleRecord,
+  Cell,
+  ColInfo,
+  ColInfos,
+  Row,
+  RowInfo,
+  RowInfos,
+  Rows,
+  Sheet,
+  Sheets,
+  Style,
+  Styles,
+} from "../abstract-sheet/abstract-sheet";
+import { xsd } from "../abstract-sheet/abstract-sheet-xsd";
+import { parseXml, parseXsd, XmlElement } from "./mustache-xml";
+
+export function abstractSheetXml(el: XmlElement): unknown {
+  const children = Array<unknown>();
+  const childElements = Array<XmlElement>();
+  for (const child of el.children ?? []) {
+    if (child.tagName !== undefined) {
+      children.push(abstractSheetXml(child));
+      childElements.push(child);
+    }
+  }
+  switch (el.tagName) {
+    case "AbstractSheet":
+      let styles: Styles | undefined = undefined;
+      let sheets: Sheets = [];
+      childElements.forEach((childEl, i) => {
+        if (childEl.tagName === "Sheets") {
+          sheets = children[i] as Sheets;
+        } else if (childEl.tagName === "Styles") {
+          styles = children[i] as Styles;
+        }
+      });
+      return { styles, sheets };
+    case "Sheets":
+      return children as Sheets;
+    case "Sheet": {
+      let rows: Rows = [];
+      let colInfo: ColInfos | undefined = undefined;
+      let rowInfo: RowInfos | undefined = undefined;
+      childElements.forEach((childEl, i) => {
+        if (childEl.tagName === "ColInfos") {
+          colInfo = children[i] as ColInfos;
+        } else if (childEl.tagName === "RowInfos") {
+          rowInfo = children[i] as RowInfos;
+        } else if (childEl.tagName === "Rows") {
+          rows = children[i] as Rows;
+        }
+      });
+      return {
+        name: ((el.attributes as Partial<Record<keyof Sheet, unknown>>)?.name ?? "") as string,
+        rows,
+        colInfo,
+        rowInfo,
+      };
+    }
+    case "ColInfos":
+      return children as ColInfos;
+    case "ColInfo":
+      return el.attributes as ColInfo;
+    case "RowInfos":
+      return children as RowInfos;
+    case "RowInfo":
+      return el.attributes as RowInfo;
+    case "Rows":
+      return children as Rows;
+    case "Row":
+      return children as Row;
+    case "Cell": {
+      return { ...el.attributes, styles: el.attributes.styles?.split(",") } as Cell;
+    }
+    case "Styles":
+      return children as Styles;
+    case "Style": {
+      const attributes: Partial<Record<keyof Style, unknown>> = { ...el.attributes };
+      if (attributes.borderStyle) {
+        const border = (attributes.borderStyle as string).toString().split(" ");
+        const s0 = borderStyleRecord[border[0] ?? ""];
+        const s1 = borderStyleRecord[border[1] ?? ""];
+        const s2 = borderStyleRecord[border[2] ?? ""];
+        const s3 = borderStyleRecord[border[3] ?? ""];
+        switch (border.length) {
+          default:
+          case 1:
+            attributes.borderStyle = { top: s0, right: s0, bottom: s0, left: s0 };
+            break;
+          case 2:
+            attributes.borderStyle = { top: s0, right: s1, bottom: s0, left: s1 };
+            break;
+          case 3:
+            attributes.borderStyle = { top: s0, right: s1, bottom: s2, left: s1 };
+            break;
+          case 4:
+            attributes.borderStyle = { top: s0, right: s1, bottom: s2, left: s3 };
+            break;
+        }
+      }
+      if (attributes.borderColor) {
+        const border = (attributes.borderColor as string).toString().split(" ");
+        const [b0, b1, b2, b3] = border;
+        switch (border.length) {
+          default:
+          case 1:
+            attributes.borderColor = { top: b0, right: b0, bottom: b0, left: b0 };
+            break;
+          case 2:
+            attributes.borderColor = { top: b0, right: b1, bottom: b0, left: b1 };
+            break;
+          case 3:
+            attributes.borderColor = { top: b0, right: b1, bottom: b2, left: b1 };
+            break;
+          case 4:
+            attributes.borderColor = { top: b0, right: b1, bottom: b2, left: b3 };
+            break;
+        }
+      }
+      return attributes as Style;
+    }
+    default:
+      throw new Error(`Could not find creator for element with name ${el.tagName}`);
+  }
+}
+
+export const parsedXsd = parseXsd(xsd);

package/src/abstract-sheet-xml/index.ts

@@ -0,0 +1,2 @@
+export * from "./abstract-sheet-xml.js";
+export * from "./mustache-xml/index.js";

package/src/abstract-sheet-xml/mustache-xml/index.ts

@@ -0,0 +1,2 @@
+export * from "./validate-mustache-xml";
+export * from "./parse-mustache-xml";

package/src/abstract-sheet-xml/mustache-xml/parse-mustache-xml.ts

@@ -0,0 +1,134 @@
+import * as FXmlP from "fast-xml-parser";
+import Mustache from "mustache";
+
+export type XmlElement = {
+  readonly tagName: string;
+  readonly attributes: Record<string, string>;
+  readonly children: ReadonlyArray<XmlElement>;
+  readonly textContent?: string;
+};
+
+export const parseMustacheXml = (
+  template: string,
+  data: any,
+  partials: Record<string, string>
+): ReadonlyArray<XmlElement> => parseXml(Mustache.render(template, data, partials));
+
+export const render = Mustache.render;
+
+export const parseXml = (text: string): ReadonlyArray<XmlElement> => transformFXP(xmlParser.parse(text));
+
+export const parseXsd = (text: string): ReadonlyArray<XmlElement> =>
+  transformFXP(xsdParser.parse(text.replace(/xs:/g, "")));
+
+type FastXmlElement = Record<string, ReadonlyArray<FastXmlElement> | Record<string, string>>;
+
+// Transforms fast-xml-parser format to a format that is much easier to work with
+function transformFXP(parsedXml: ReadonlyArray<FastXmlElement>): ReadonlyArray<XmlElement> {
+  return parsedXml.flatMap((element) => {
+    const key = Object.keys(element).find((k) => k !== ":@" && k !== "#text")!;
+    if (key === "?xml") {
+      return [];
+    }
+    const children = ((element[key] || []) as Array<FastXmlElement>).filter((c) => {
+      const key = Object.keys(c)[0];
+      return key !== "#text" && key !== ":@";
+    });
+    const attributes = (element[":@"] as Record<string, string>) || {};
+    const textChilds: Array<string> = ((element[key] || []) as Array<FastXmlElement>)
+      .filter((c) => {
+        const key = Object.keys(c)[0];
+        return key === "#text";
+      })
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .flatMap((t) => t["#text"] as any as string);
+    const textContents = textChilds.flatMap((text) => {
+      const cleaned = text.replace(/\n/g, "").replace(/\t/g, "").trim();
+      return cleaned ? [text] : [];
+    });
+    const textContent = textContents.join("\n");
+    return { tagName: key, attributes: attributes, children: transformFXP(children), textContent: textContent };
+  });
+}
+
+export function findElement(
+  elements: ReadonlyArray<XmlElement>,
+  elementName: string | undefined
+): XmlElement | undefined {
+  if (!elementName) {
+    return undefined;
+  }
+  for (const elem of elements) {
+    if (elem.tagName === "annotation" || elem.tagName === "attribute") {
+      continue;
+    }
+    if (shouldSkipLevel(elem)) {
+      const childElement = findElement(Array.from(elem.children), elementName);
+      if (childElement) {
+        return shouldSkipLevel(childElement)
+          ? findElement(Array.from(childElement.children), elementName)
+          : childElement;
+      }
+    }
+    if (elem.attributes.name === elementName) {
+      return elem;
+    }
+  }
+  return undefined;
+}
+
+export function getChildren(elements: ReadonlyArray<XmlElement>): ReadonlyArray<XmlElement> {
+  for (const elem of elements) {
+    if (elem.tagName === "annotation" || elem.tagName === "attribute") {
+      continue;
+    }
+    if (shouldSkipLevel(elem)) {
+      const child = getChildren(Array.from(elem.children));
+      if (child.length > 0) {
+        return child.flatMap((c) => (shouldSkipLevel(c) ? getChildren(Array.from(c.children)) : c));
+      }
+    }
+    return elements;
+  }
+  return [];
+}
+
+function shouldSkipLevel(tag: XmlElement): boolean {
+  return (
+    tag.tagName === "all" || tag.tagName === "sequence" || tag.tagName === "choice" || tag.attributes.name === undefined
+  );
+}
+
+const xmlParser = new FXmlP.XMLParser({
+  preserveOrder: true,
+  ignoreAttributes: false,
+  attributeNamePrefix: "",
+  allowBooleanAttributes: true,
+  trimValues: false,
+  ignoreDeclaration: true,
+  processEntities: true,
+  htmlEntities: true,
+  attributeValueProcessor: (_name, value) => {
+    if (!value?.trim()) {
+      return value;
+    }
+    const nValue = Number(value);
+    if (!Number.isNaN(nValue)) {
+      return nValue;
+    }
+    return value;
+  },
+});
+xmlParser.addEntity("#x2F", "/");
+xmlParser.addEntity("#x3D", "=");
+
+const xsdParser = new FXmlP.XMLParser({
+  preserveOrder: true,
+  ignoreAttributes: false,
+  attributeNamePrefix: "",
+  allowBooleanAttributes: true,
+  trimValues: false,
+  ignoreDeclaration: true,
+});
+xsdParser.addEntity("#x2F", "/");
+xsdParser.addEntity("#x3D", "=");