abstract-document 6.9.4 → 6.9.5

package/src/abstract-document/markdown/markdown.ts

@@ -1,142 +1,142 @@
-import unified from "unified";
-import remarkParse from "remark-parse";
-import remarkSubSuper from "remark-sub-super";
-import { SectionElement } from "../section-elements/section-element";
-import * as Paragraph from "../section-elements/paragraph";
-import * as Atom from "../atoms/atom";
-import * as TextRun from "../atoms/text-run";
-import * as Group from "../section-elements/group";
-import { AstElements, MarkDownProcessData, AstRoot } from "./types";
-
-export interface MarkdownProps {
-  readonly text: string;
-  readonly keepTogetherSections?: boolean;
-}
-
-interface ListItemParams {
-  readonly ordered: boolean;
-  readonly start: number;
-  readonly level: number;
-  readonly firstChild: AstElements;
-}
-
-function preProcessMarkdownAst(
-  ast: AstElements,
-  styles: Array<string>,
-  atoms: Array<Atom.Atom>,
-  paragraphs: Array<Paragraph.Paragraph>,
-  d: number,
-  listItemParams: ListItemParams | undefined = undefined
-): MarkDownProcessData {
-  if (ast.type === "text") {
-    return { atoms, paragraphs };
-  } // Need to convice TS that we never go below this line with a Str element.
-
-  if (ast.children) {
-    ast.children.forEach((child) => {
-      let style = styles.slice(); // create a new copy of styles
-      switch (ast.type) {
-        case "heading":
-          style.push("H" + ast.depth);
-          break;
-        case "emphasis":
-          style.push("Emphasis");
-          break;
-        case "strong":
-          style.push("Strong");
-          break;
-        case "sub":
-          style.push("Subscript");
-          break;
-        case "sup":
-          style.push("Superscript");
-          break;
-        default:
-          break;
-      }
-
-      const newListItemParams =
-        child.type === "list"
-          ? {
-              ordered: child.ordered === true,
-              start: child.start || 1,
-              level: listItemParams ? listItemParams.level + 1 : 0,
-              firstChild: child.children[0],
-            }
-          : listItemParams;
-
-      // Recurse down the rabbit hole until we find a Str.
-      ({ atoms, paragraphs } = preProcessMarkdownAst(child, style, atoms, paragraphs, d + 1, newListItemParams));
-
-      // After child, check if we should create a new paragraph.
-      if (child.type === "paragraph" || child.type === "heading") {
-        const paragraphStyle = child.type === "heading" ? "H" + child.depth : undefined;
-
-        const paragraphNumbering = listItemParams
-          ? {
-              level: listItemParams.level,
-              numberingId: listItemParams.ordered ? "Ordered" : "Unordered",
-              numberOverride: ast === listItemParams.firstChild ? listItemParams.start : undefined,
-              append: ast.type === "listItem" && child !== ast.children[0],
-            }
-          : undefined;
-
-        paragraphs.push(
-          Paragraph.create(
-            {
-              styleName: paragraphStyle,
-              numbering: paragraphNumbering,
-            },
-            atoms
-          )
-        );
-        atoms = []; // Flush the Atoms-array for the next paragraph.
-      } else if (child.type === "text") {
-        atoms = atoms.concat(
-          child.value.split("\n").map(
-            (v: string) =>
-              ({
-                type: "TextRun",
-                text: v,
-                styleName: style[style.length - 1],
-                nestedStyleNames: style,
-                textProperties: {},
-              } as TextRun.TextRun)
-          )
-        );
-      }
-    });
-  }
-
-  return { atoms, paragraphs };
-}
-
-export function create({ text, keepTogetherSections }: MarkdownProps): Array<SectionElement> {
-  const ast = unified().use(remarkParse, { commonmark: true }).use(remarkSubSuper).parse(text);
-  const { paragraphs } = preProcessMarkdownAst(ast as AstRoot, [], [], [], 0);
-  if (!keepTogetherSections) {
-    return paragraphs;
-  }
-  const groups: Array<Array<SectionElement>> = [];
-  let group: Array<SectionElement> = [];
-  let i = 0;
-  while (i < paragraphs.length) {
-    while (i < paragraphs.length && paragraphs[i].styleName.startsWith("H")) {
-      group.push(paragraphs[i]);
-      ++i;
-    }
-    if (i < paragraphs.length) {
-      group.push(paragraphs[i]);
-    }
-    if (group.length > 0) {
-      groups.push(group);
-      group = [];
-    }
-    ++i;
-  }
-  if (groups.length > 0) {
-    return groups.map((group) => Group.create({ keepTogether: true }, group));
-  } else {
-    return [Group.create({ keepTogether: true }, [])];
-  }
-}
+import unified from "unified";
+import remarkParse from "remark-parse";
+import remarkSubSuper from "remark-sub-super";
+import { SectionElement } from "../section-elements/section-element";
+import * as Paragraph from "../section-elements/paragraph";
+import * as Atom from "../atoms/atom";
+import * as TextRun from "../atoms/text-run";
+import * as Group from "../section-elements/group";
+import { AstElements, MarkDownProcessData, AstRoot } from "./types";
+
+export interface MarkdownProps {
+  readonly text: string;
+  readonly keepTogetherSections?: boolean;
+}
+
+interface ListItemParams {
+  readonly ordered: boolean;
+  readonly start: number;
+  readonly level: number;
+  readonly firstChild: AstElements;
+}
+
+function preProcessMarkdownAst(
+  ast: AstElements,
+  styles: Array<string>,
+  atoms: Array<Atom.Atom>,
+  paragraphs: Array<Paragraph.Paragraph>,
+  d: number,
+  listItemParams: ListItemParams | undefined = undefined
+): MarkDownProcessData {
+  if (ast.type === "text") {
+    return { atoms, paragraphs };
+  } // Need to convice TS that we never go below this line with a Str element.
+
+  if (ast.children) {
+    ast.children.forEach((child) => {
+      let style = styles.slice(); // create a new copy of styles
+      switch (ast.type) {
+        case "heading":
+          style.push("H" + ast.depth);
+          break;
+        case "emphasis":
+          style.push("Emphasis");
+          break;
+        case "strong":
+          style.push("Strong");
+          break;
+        case "sub":
+          style.push("Subscript");
+          break;
+        case "sup":
+          style.push("Superscript");
+          break;
+        default:
+          break;
+      }
+
+      const newListItemParams =
+        child.type === "list"
+          ? {
+              ordered: child.ordered === true,
+              start: child.start || 1,
+              level: listItemParams ? listItemParams.level + 1 : 0,
+              firstChild: child.children[0],
+            }
+          : listItemParams;
+
+      // Recurse down the rabbit hole until we find a Str.
+      ({ atoms, paragraphs } = preProcessMarkdownAst(child, style, atoms, paragraphs, d + 1, newListItemParams));
+
+      // After child, check if we should create a new paragraph.
+      if (child.type === "paragraph" || child.type === "heading") {
+        const paragraphStyle = child.type === "heading" ? "H" + child.depth : undefined;
+
+        const paragraphNumbering = listItemParams
+          ? {
+              level: listItemParams.level,
+              numberingId: listItemParams.ordered ? "Ordered" : "Unordered",
+              numberOverride: ast === listItemParams.firstChild ? listItemParams.start : undefined,
+              append: ast.type === "listItem" && child !== ast.children[0],
+            }
+          : undefined;
+
+        paragraphs.push(
+          Paragraph.create(
+            {
+              styleName: paragraphStyle,
+              numbering: paragraphNumbering,
+            },
+            atoms
+          )
+        );
+        atoms = []; // Flush the Atoms-array for the next paragraph.
+      } else if (child.type === "text") {
+        atoms = atoms.concat(
+          child.value.split("\n").map(
+            (v: string) =>
+              ({
+                type: "TextRun",
+                text: v,
+                styleName: style[style.length - 1],
+                nestedStyleNames: style,
+                textProperties: {},
+              } as TextRun.TextRun)
+          )
+        );
+      }
+    });
+  }
+
+  return { atoms, paragraphs };
+}
+
+export function create({ text, keepTogetherSections }: MarkdownProps): Array<SectionElement> {
+  const ast = unified().use(remarkParse, { commonmark: true }).use(remarkSubSuper).parse(text);
+  const { paragraphs } = preProcessMarkdownAst(ast as AstRoot, [], [], [], 0);
+  if (!keepTogetherSections) {
+    return paragraphs;
+  }
+  const groups: Array<Array<SectionElement>> = [];
+  let group: Array<SectionElement> = [];
+  let i = 0;
+  while (i < paragraphs.length) {
+    while (i < paragraphs.length && paragraphs[i].styleName.startsWith("H")) {
+      group.push(paragraphs[i]);
+      ++i;
+    }
+    if (i < paragraphs.length) {
+      group.push(paragraphs[i]);
+    }
+    if (group.length > 0) {
+      groups.push(group);
+      group = [];
+    }
+    ++i;
+  }
+  if (groups.length > 0) {
+    return groups.map((group) => Group.create({ keepTogether: true }, group));
+  } else {
+    return [Group.create({ keepTogether: true }, [])];
+  }
+}

package/src/abstract-document/markdown/types.ts

@@ -1,78 +1,78 @@
-import * as AD from "../../abstract-document/index";
-
-export type AstChildElements =
-  | AstHeading
-  | AstText
-  | AstParagraph
-  | AstEmphasis
-  | AstStrong
-  | AstSubscript
-  | AstSuperscript
-  | AstList
-  | AstListItem;
-export type AstElements = AstRoot | AstChildElements;
-
-export interface AstMetaLoc {
-  readonly start: { readonly line: number; readonly column: number };
-  readonly end: { readonly line: number; readonly column: number };
-}
-
-export interface AstParagraph {
-  readonly type: "paragraph";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstEmphasis {
-  readonly type: "emphasis";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstStrong {
-  readonly type: "strong";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstSubscript {
-  readonly type: "sub";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstSuperscript {
-  readonly type: "sup";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstText {
-  readonly type: "text";
-  readonly value: string;
-}
-
-export interface AstHeading {
-  readonly type: "heading";
-  readonly depth: number;
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstRoot {
-  readonly type: "root";
-  readonly children: Array<AstChildElements>;
-}
-
-export interface AstList {
-  readonly type: "list";
-  readonly ordered?: boolean;
-  readonly start?: number;
-  readonly spread?: boolean;
-  readonly children: Array<AstChildElements>; // technically only AstListItem appears hear
-}
-
-export interface AstListItem {
-  readonly type: "listItem";
-  readonly spread?: boolean;
-  readonly children: Array<AstChildElements>;
-}
-
-export interface MarkDownProcessData {
-  readonly atoms: Array<AD.Atom.Atom>;
-  readonly paragraphs: Array<AD.Paragraph.Paragraph>;
-}
+import * as AD from "../../abstract-document/index";
+
+export type AstChildElements =
+  | AstHeading
+  | AstText
+  | AstParagraph
+  | AstEmphasis
+  | AstStrong
+  | AstSubscript
+  | AstSuperscript
+  | AstList
+  | AstListItem;
+export type AstElements = AstRoot | AstChildElements;
+
+export interface AstMetaLoc {
+  readonly start: { readonly line: number; readonly column: number };
+  readonly end: { readonly line: number; readonly column: number };
+}
+
+export interface AstParagraph {
+  readonly type: "paragraph";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstEmphasis {
+  readonly type: "emphasis";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstStrong {
+  readonly type: "strong";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstSubscript {
+  readonly type: "sub";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstSuperscript {
+  readonly type: "sup";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstText {
+  readonly type: "text";
+  readonly value: string;
+}
+
+export interface AstHeading {
+  readonly type: "heading";
+  readonly depth: number;
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstRoot {
+  readonly type: "root";
+  readonly children: Array<AstChildElements>;
+}
+
+export interface AstList {
+  readonly type: "list";
+  readonly ordered?: boolean;
+  readonly start?: number;
+  readonly spread?: boolean;
+  readonly children: Array<AstChildElements>; // technically only AstListItem appears hear
+}
+
+export interface AstListItem {
+  readonly type: "listItem";
+  readonly spread?: boolean;
+  readonly children: Array<AstChildElements>;
+}
+
+export interface MarkDownProcessData {
+  readonly atoms: Array<AD.Atom.Atom>;
+  readonly paragraphs: Array<AD.Paragraph.Paragraph>;
+}

package/src/abstract-document/numberings/numbering-definition.ts

@@ -1,17 +1,17 @@
-import { NumberingLevelDefinition } from "./numbering-level-definition";
-
-export interface NumberingDefinition {
-  readonly levels: NumberingLevelDefinition[];
-}
-
-export interface NumberingDefinitionProps {
-  readonly levels: NumberingLevelDefinition[];
-}
-
-export function create({
-  levels
-}: NumberingDefinitionProps): NumberingDefinition {
-  return {
-    levels
-  };
-}
+import { NumberingLevelDefinition } from "./numbering-level-definition";
+
+export interface NumberingDefinition {
+  readonly levels: NumberingLevelDefinition[];
+}
+
+export interface NumberingDefinitionProps {
+  readonly levels: NumberingLevelDefinition[];
+}
+
+export function create({
+  levels
+}: NumberingDefinitionProps): NumberingDefinition {
+  return {
+    levels
+  };
+}

package/src/abstract-document/numberings/numbering-format.ts

@@ -1,7 +1,7 @@
-export type NumberingFormat =
-  | "Decimal"
-  | "DecimalZero"
-  | "LowerLetter"
-  | "UpperLetter"
-  | "LowerRoman"
-  | "UpperRoman";
+export type NumberingFormat =
+  | "Decimal"
+  | "DecimalZero"
+  | "LowerLetter"
+  | "UpperLetter"
+  | "LowerRoman"
+  | "UpperRoman";

package/src/abstract-document/numberings/numbering-level-definition.ts

@@ -1,42 +1,42 @@
-import * as TextStyle from "../styles/text-style";
-import { NumberingFormat } from "./numbering-format";
-
-export interface NumberingLevelDefinition {
-  readonly level: number;
-  readonly format: NumberingFormat;
-  readonly start: number;
-  readonly levelText: string;
-  readonly levelIndention: number;
-  readonly numberingWidth: number;
-  readonly style: TextStyle.TextStyle;
-}
-
-export interface NumberingLevelDefinitionProps {
-  readonly level: number;
-  readonly format: NumberingFormat;
-  readonly start: number;
-  readonly levelText: string;
-  readonly levelIndention: number;
-  readonly numberingWidth?: number;
-  readonly style?: TextStyle.TextStyle;
-}
-
-export function create({
-  level,
-  format,
-  start,
-  levelText,
-  levelIndention,
-  numberingWidth,
-  style
-}: NumberingLevelDefinitionProps): NumberingLevelDefinition {
-  return {
-    level,
-    format,
-    start,
-    levelText,
-    levelIndention,
-    numberingWidth: numberingWidth || 40,
-    style: style || TextStyle.create()
-  };
-}
+import * as TextStyle from "../styles/text-style";
+import { NumberingFormat } from "./numbering-format";
+
+export interface NumberingLevelDefinition {
+  readonly level: number;
+  readonly format: NumberingFormat;
+  readonly start: number;
+  readonly levelText: string;
+  readonly levelIndention: number;
+  readonly numberingWidth: number;
+  readonly style: TextStyle.TextStyle;
+}
+
+export interface NumberingLevelDefinitionProps {
+  readonly level: number;
+  readonly format: NumberingFormat;
+  readonly start: number;
+  readonly levelText: string;
+  readonly levelIndention: number;
+  readonly numberingWidth?: number;
+  readonly style?: TextStyle.TextStyle;
+}
+
+export function create({
+  level,
+  format,
+  start,
+  levelText,
+  levelIndention,
+  numberingWidth,
+  style
+}: NumberingLevelDefinitionProps): NumberingLevelDefinition {
+  return {
+    level,
+    format,
+    start,
+    levelText,
+    levelIndention,
+    numberingWidth: numberingWidth || 40,
+    style: style || TextStyle.create()
+  };
+}

package/src/abstract-document/numberings/numbering.ts

@@ -1,3 +1,3 @@
-export interface Numbering {
-  readonly definitionId: string;
-}
+export interface Numbering {
+  readonly definitionId: string;
+}

package/src/abstract-document/page/master-page.ts

@@ -1,23 +1,23 @@
-import * as PageStyle from "../styles/page-style";
-import * as SectionElement from "../section-elements/section-element";
-
-export interface MasterPage {
-  readonly style: PageStyle.PageStyle;
-  readonly header: Array<SectionElement.SectionElement>;
-  readonly footer: Array<SectionElement.SectionElement>;
-}
-
-export interface MasterPageProps {
-  readonly style?: PageStyle.PageStyle;
-  readonly header?: Array<SectionElement.SectionElement>;
-  readonly footer?: Array<SectionElement.SectionElement>;
-}
-
-export function create(props?: MasterPageProps): MasterPage {
-  const { style = PageStyle.create(), header = [], footer = [] } = props || {};
-  return {
-    style,
-    header,
-    footer
-  };
-}
+import * as PageStyle from "../styles/page-style";
+import * as SectionElement from "../section-elements/section-element";
+
+export interface MasterPage {
+  readonly style: PageStyle.PageStyle;
+  readonly header: Array<SectionElement.SectionElement>;
+  readonly footer: Array<SectionElement.SectionElement>;
+}
+
+export interface MasterPageProps {
+  readonly style?: PageStyle.PageStyle;
+  readonly header?: Array<SectionElement.SectionElement>;
+  readonly footer?: Array<SectionElement.SectionElement>;
+}
+
+export function create(props?: MasterPageProps): MasterPage {
+  const { style = PageStyle.create(), header = [], footer = [] } = props || {};
+  return {
+    style,
+    header,
+    footer
+  };
+}