abstract-document 6.0.2 → 6.0.3

package/src/abstract-document/index.ts

@@ -1,83 +1,83 @@
-import * as AbstractDoc from "./abstract-doc";
-import * as Atom from "./atoms/atom";
-import * as Image from "./atoms/image";
-import * as TextField from "./atoms/text-field";
-import * as TextRun from "./atoms/text-run";
-import * as HyperLink from "./atoms/hyper-link";
-import * as LinkTarget from "./atoms/link-target";
-import * as TocSeparator from "./atoms/toc-separator";
-import * as Font from "./primitives/font";
-import * as Numbering from "./numberings/numbering";
-import * as NumberingDefinition from "./numberings/numbering-definition";
-import * as NumberingFormat from "./numberings/numbering-format";
-import * as NumberingLevelDefinition from "./numberings/numbering-level-definition";
-import * as MasterPage from "./page/master-page";
-import * as Section from "./page/section";
-import * as Length from "./primitives/length";
-import * as ImageResource from "./primitives/image-resource";
-import * as LayoutFoundation from "./primitives/layout-foundation";
-import * as Point from "./primitives/point";
-import * as Rect from "./primitives/rect";
-import * as Size from "./primitives/size";
-import * as Group from "./section-elements/group";
-import * as Paragraph from "./section-elements/paragraph";
-import * as ParagraphNumbering from "./section-elements/paragraph-numbering";
-import * as SectionElement from "./section-elements/section-element";
-import * as Table from "./section-elements/table";
-import * as PageStyle from "./styles/page-style";
-import * as ParagraphStyle from "./styles/paragraph-style";
-import * as Style from "./styles/style";
-import * as StyleKey from "./styles/style-key";
-import * as TableCellStyle from "./styles/table-cell-style";
-import * as TableStyle from "./styles/table-style";
-import * as TextStyle from "./styles/text-style";
-import * as TableCell from "./table/table-cell";
-import * as TableRow from "./table/table-row";
-import * as DefaultStyles from "./default-styles";
-import * as Markdown from "./markdown/markdown";
-import * as Resources from "./resources";
-import * as Types from "./types";
-import * as PageBreak from "./section-elements/page-break";
-
-export {
-  AbstractDoc,
-  Atom,
-  Image,
-  TextField,
-  TextRun,
-  HyperLink,
-  LinkTarget,
-  TocSeparator,
-  Font,
-  Numbering,
-  NumberingDefinition,
-  NumberingFormat,
-  NumberingLevelDefinition,
-  MasterPage,
-  Section,
-  Length,
-  ImageResource,
-  LayoutFoundation,
-  Point,
-  Rect,
-  Size,
-  Group,
-  Paragraph,
-  ParagraphNumbering,
-  SectionElement,
-  Table,
-  Markdown,
-  PageStyle,
-  ParagraphStyle,
-  Style,
-  StyleKey,
-  TableCellStyle,
-  TableStyle,
-  TextStyle,
-  TableCell,
-  TableRow,
-  DefaultStyles,
-  Resources,
-  Types,
-  PageBreak
-};
+import * as AbstractDoc from "./abstract-doc";
+import * as Atom from "./atoms/atom";
+import * as Image from "./atoms/image";
+import * as TextField from "./atoms/text-field";
+import * as TextRun from "./atoms/text-run";
+import * as HyperLink from "./atoms/hyper-link";
+import * as LinkTarget from "./atoms/link-target";
+import * as TocSeparator from "./atoms/toc-separator";
+import * as Font from "./primitives/font";
+import * as Numbering from "./numberings/numbering";
+import * as NumberingDefinition from "./numberings/numbering-definition";
+import * as NumberingFormat from "./numberings/numbering-format";
+import * as NumberingLevelDefinition from "./numberings/numbering-level-definition";
+import * as MasterPage from "./page/master-page";
+import * as Section from "./page/section";
+import * as Length from "./primitives/length";
+import * as ImageResource from "./primitives/image-resource";
+import * as LayoutFoundation from "./primitives/layout-foundation";
+import * as Point from "./primitives/point";
+import * as Rect from "./primitives/rect";
+import * as Size from "./primitives/size";
+import * as Group from "./section-elements/group";
+import * as Paragraph from "./section-elements/paragraph";
+import * as ParagraphNumbering from "./section-elements/paragraph-numbering";
+import * as SectionElement from "./section-elements/section-element";
+import * as Table from "./section-elements/table";
+import * as PageStyle from "./styles/page-style";
+import * as ParagraphStyle from "./styles/paragraph-style";
+import * as Style from "./styles/style";
+import * as StyleKey from "./styles/style-key";
+import * as TableCellStyle from "./styles/table-cell-style";
+import * as TableStyle from "./styles/table-style";
+import * as TextStyle from "./styles/text-style";
+import * as TableCell from "./table/table-cell";
+import * as TableRow from "./table/table-row";
+import * as DefaultStyles from "./default-styles";
+import * as Markdown from "./markdown/markdown";
+import * as Resources from "./resources";
+import * as Types from "./types";
+import * as PageBreak from "./section-elements/page-break";
+
+export {
+  AbstractDoc,
+  Atom,
+  Image,
+  TextField,
+  TextRun,
+  HyperLink,
+  LinkTarget,
+  TocSeparator,
+  Font,
+  Numbering,
+  NumberingDefinition,
+  NumberingFormat,
+  NumberingLevelDefinition,
+  MasterPage,
+  Section,
+  Length,
+  ImageResource,
+  LayoutFoundation,
+  Point,
+  Rect,
+  Size,
+  Group,
+  Paragraph,
+  ParagraphNumbering,
+  SectionElement,
+  Table,
+  Markdown,
+  PageStyle,
+  ParagraphStyle,
+  Style,
+  StyleKey,
+  TableCellStyle,
+  TableStyle,
+  TextStyle,
+  TableCell,
+  TableRow,
+  DefaultStyles,
+  Resources,
+  Types,
+  PageBreak
+};

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";