cvdl-ts 1.0.12 → 1.0.14

package/dist/AnyLayout.d.ts

@@ -34,4 +34,4 @@ export declare class FontDict {
     load_fonts_from_schema(schema: LayoutSchema, storage: Storage): Promise<void>;
     get_font(name: string): fontkit.Font;
 }
-export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }: RenderProps): Promise<[FontDict, Layout.RenderedLayout[]]>;
+export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }: RenderProps): Promise<Layout.RenderedLayout[]>;

package/dist/AnyLayout.js

@@ -54,8 +54,6 @@ class FontDict {
 }
 exports.FontDict = FontDict;
 async function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }) {
-    // Each box contains a set of elements(positioned by 0x0 and projected into its bounding box)
-    const font_dict = fontDict !== null && fontDict !== void 0 ? fontDict : new FontDict();
     // Compute the total usable width by subtracting the margins from the document width
     const width = resume_layout.width - (resume_layout.margin.left + resume_layout.margin.right);
     // If the resume is double column, then the usable width is halved
@@ -65,7 +63,6 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
     const layouts = [];
     console.error("Rendering sections...");
     for (const section of resume.sections) {
-        console.error("Print section:", section);
         // Render Section Header
         // 1. Find the layout schema for the section
         console.info("Computing section: ", section.section_name);
@@ -75,48 +72,34 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
             throw new Error(`Could not find layout schema ${section.layout_schema}`);
         }
         let start_time = Date.now();
-        await font_dict.load_fonts_from_schema(layout_schema, storage);
+        await fontDict.load_fonts_from_schema(layout_schema, storage);
         let end_time = Date.now();
         console.info(`Font loading time: ${end_time - start_time}ms for section ${section.section_name}`);
         // 2. Find the data schema for the section
-        const _data_schema = data_schemas.find(s => s.schema_name === section.data_schema);
-        if (_data_schema === undefined) {
+        const data_schema = data_schemas.find(s => s.schema_name === section.data_schema);
+        if (data_schema === undefined) {
             throw new Error(`Could not find data schema ${section.data_schema}`);
         }
         start_time = Date.now();
         // 3. Render the header
-        const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data), column_width, font_dict), font_dict);
-        console.error("Header is computed");
+        const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema), column_width, fontDict), fontDict);
+        layout.path = { tag: 'section', section: section.section_name };
+        console.info("Header is computed");
         layouts.push(layout);
         end_time = Date.now();
         console.info(`Header rendering time: ${end_time - start_time}ms for section ${section.section_name}`);
         start_time = Date.now();
         // Render Section Items
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        // @ts-nocheck
         for (const [index, item] of section.items.entries()) {
-            console.log("Computing item");
-            console.error("Item:", item);
-            // 1. Find the layout schema for the section
-            const layout_schema = layout_schemas
-                .find((s) => s.schema_name == section.layout_schema);
-            if (layout_schema == undefined) {
-                throw new Error(`Could not find layout schema ${section.layout_schema}`);
-            }
-            await font_dict.load_fonts_from_schema(layout_schema, storage);
-            console.log("Fonts are loaded");
-            // 2. Find the data schema for the section
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _data_schema = data_schemas
-                .find((s) => s.schema_name == section.data_schema);
             // 3. Render the item
-            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields), column_width, font_dict), font_dict);
+            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields, data_schema.item_schema), column_width, fontDict), fontDict);
+            layout.path = { tag: 'item', section: section.section_name, item: index };
             layouts.push(layout);
         }
         end_time = Date.now();
         console.info(`Item rendering time: ${end_time - start_time}ms for section ${section.section_name}`);
     }
     console.log("Position calculations are completed.");
-    return [font_dict, layouts];
+    return layouts;
 }
 exports.render = render;

package/dist/DataSchema.d.ts

@@ -1,32 +1,44 @@
-export type DocumentDataType = {
-    tag: "Date";
-} | {
-    tag: "String";
-} | {
-    tag: "MarkdownString";
-} | {
-    tag: "Type";
-    value: string;
-} | {
-    tag: "List";
-    value: DocumentDataType;
-} | {
-    tag: "Types";
-    value: DocumentDataType[];
-};
-export type Field = {
-    name: string;
-    data_type: DocumentDataType;
-};
+export declare namespace DocumentDataType {
+    type t = {
+        tag: "Date";
+    } | {
+        tag: "String";
+    } | {
+        tag: "MarkdownString";
+    } | {
+        tag: "Number";
+    } | {
+        tag: "Type";
+        value: string;
+    } | {
+        tag: "List";
+        value: t;
+    } | {
+        tag: "Types";
+        value: t[];
+    };
+    type DocumentDataType = t;
+    function parse(s: string): DocumentDataType;
+    function print(d: DocumentDataType): string;
+}
+export declare namespace Field {
+    type t = {
+        name: string;
+        type: DocumentDataType.t;
+    };
+    type Field = t;
+    function fromJson(json: unknown): Field;
+    function toJson(f: Field): unknown;
+}
 export declare class DataSchema {
     schema_name: string;
-    header_schema: Field[];
-    item_schema: Field[];
-    constructor(schema_name: string, header_schema: Field[], item_schema: Field[]);
+    header_schema: Field.t[];
+    item_schema: Field.t[];
+    constructor(schema_name: string, header_schema: Field.t[], item_schema: Field.t[]);
     static fromJson(json: unknown): DataSchema;
     toJson(): {
         schema_name: string;
-        header_schema: Field[];
-        item_schema: Field[];
+        header_schema: unknown[];
+        item_schema: unknown[];
     };
 }

package/dist/DataSchema.js

@@ -1,6 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSchema = void 0;
+exports.DataSchema = exports.Field = exports.DocumentDataType = void 0;
+var DocumentDataType;
+(function (DocumentDataType) {
+    function parse(s) {
+        if (s === "Date") {
+            return { tag: "Date" };
+        }
+        else if (s === "String") {
+            return { tag: "String" };
+        }
+        else if (s === "MarkdownString") {
+            return { tag: "MarkdownString" };
+        }
+        else if (s === "Number") {
+            return { tag: "Number" };
+        }
+        else if (s.startsWith("List")) {
+            return { tag: "List", value: parse(s.slice(5, -1).trim()) };
+        }
+        else if (s.includes("|")) {
+            return { tag: "Types", value: s.split("|").map((s) => s.trim()).map(parse) };
+        }
+        else {
+            throw new Error("Invalid DocumentDataType: " + s);
+        }
+    }
+    DocumentDataType.parse = parse;
+    function print(d) {
+        switch (d.tag) {
+            case "Date":
+                return "Date";
+            case "String":
+                return "String";
+            case "MarkdownString":
+                return "MarkdownString";
+            case "Number":
+                return "Number";
+            case "Type":
+                return d.value;
+            case "List":
+                return "List<" + print(d.value) + ">";
+            case "Types":
+                return d.value.map(print).join(" | ");
+        }
+    }
+    DocumentDataType.print = print;
+})(DocumentDataType || (exports.DocumentDataType = DocumentDataType = {}));
+var Field;
+(function (Field) {
+    function fromJson(json) {
+        if (typeof json !== "object" || json === null) {
+            throw new Error("Field must be an object");
+        }
+        if (!("name" in json) || !("type" in json)) {
+            throw new Error("Field must have a name and type");
+        }
+        if (typeof json.name !== "string") {
+            throw new Error("Field name must be a string");
+        }
+        if (typeof json.type !== "string") {
+            throw new Error("Field type must be a string");
+        }
+        return {
+            name: json.name,
+            type: DocumentDataType.parse(json.type),
+        };
+    }
+    Field.fromJson = fromJson;
+    function toJson(f) {
+        return {
+            name: f.name,
+            type: DocumentDataType.print(f.type),
+        };
+    }
+    Field.toJson = toJson;
+})(Field || (exports.Field = Field = {}));
 class DataSchema {
     constructor(schema_name, header_schema, item_schema) {
         this.schema_name = schema_name;
@@ -14,13 +89,13 @@ class DataSchema {
         if (!("schema_name" in json) || !("header_schema" in json) || !("item_schema" in json)) {
             throw new Error("DataSchema must have a schema_name, header_schema, and item_schema");
         }
-        return new DataSchema(json.schema_name, json.header_schema, json.item_schema);
+        return new DataSchema(json.schema_name, json.header_schema.map(Field.fromJson), json.item_schema.map(Field.fromJson));
     }
     toJson() {
         return {
             schema_name: this.schema_name,
-            header_schema: this.header_schema,
-            item_schema: this.item_schema,
+            header_schema: this.header_schema.map(Field.toJson),
+            item_schema: this.item_schema.map(Field.toJson),
         };
     }
 }

package/dist/Elem.d.ts

@@ -4,12 +4,29 @@ import { Color } from "./Layout";
 import { FontDict } from "./AnyLayout";
 import * as Row from "./Row";
 import { ItemContent } from "./Resume";
+import { Field } from "./DataSchema";
+import { Optional } from "./Utils";
+import { Box } from "./Box";
+export type Span = {
+    is_italic: boolean;
+    is_bold: boolean;
+    is_code: boolean;
+    text: string;
+    link: string | null;
+    font?: Font.t;
+    width?: number;
+    line?: number;
+    bbox?: Box;
+};
 export type t = {
     tag: "Elem";
     item: string;
+    text?: string;
+    spans?: Span[];
     url: string | null;
     is_ref: boolean;
     is_fill: boolean;
+    is_markdown: boolean;
     text_width: Width.t;
     font: Font.t;
     margin: Margin.t;
@@ -18,13 +35,16 @@ export type t = {
     background_color: Color;
 };
 type Elem = t;
-export declare function elem(item: string, url: string | null, is_ref: boolean, is_fill: boolean, text_width: Width.t, font: Font.t, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color): Elem;
+export declare function elem(item: string, url: string | null, is_ref: boolean, is_fill: boolean, is_markdown: boolean, text_width: Width.t, font: Font.t, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color): Elem;
 export declare function copy(e: Elem): {
     tag: "Elem";
     item: string;
+    text?: string;
+    spans?: Span[];
     url: string;
     is_ref: boolean;
     is_fill: boolean;
+    is_markdown: boolean;
     text_width: Width.t;
     font: Font.t;
     margin: Margin.t;
@@ -33,10 +53,6 @@ export declare function copy(e: Elem): {
     background_color: Layout.Color;
 };
 export declare function default_(): Elem;
-export type Optional<T> = {
-    [P in keyof T]?: T[P];
-};
-export declare function with_(e: Elem, w: Optional<Elem>): Elem;
 export declare function from(w: Optional<Elem>): Elem;
 export declare function withItem(e: Elem, item: string): Elem;
 export declare function withUrl(e: Elem, url: string | null): Elem;
@@ -50,9 +66,10 @@ export declare function withAlignment(e: Elem, alignment: Alignment.t): Elem;
 export declare function withWidth(e: Elem, width: Width.t): Elem;
 export declare function withBackgroundColor(e: Elem, background_color: Color): Elem;
 export declare function scaleWidth(e: Elem, scale: number): Elem;
+export declare function parseMarkdownItem(item: string): Span[];
 export declare function fillFonts(e: Elem, fonts: FontDict): Elem;
 export declare function justifiedLines(e: Elem, lines: Elem[], font_dict: FontDict): Row.t[];
 export declare function break_lines(e: Elem, font_dict: FontDict): Layout.t[];
 export declare function boundWidth(e: Elem, width: number): Elem;
-export declare function instantiate(e: Elem, section: Map<string, ItemContent>): Elem;
+export declare function instantiate(e: Elem, section: Map<string, ItemContent>, fields: Field.t[]): Elem;
 export {};

package/dist/Elem.js

@@ -23,18 +23,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.instantiate = exports.boundWidth = exports.break_lines = exports.justifiedLines = exports.fillFonts = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.with_ = exports.default_ = exports.copy = exports.elem = void 0;
+exports.instantiate = exports.boundWidth = exports.break_lines = exports.justifiedLines = exports.fillFonts = exports.parseMarkdownItem = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.default_ = exports.copy = exports.elem = void 0;
 const Font = __importStar(require("./Font"));
 const _1 = require(".");
 const Row_1 = require("./Row");
 const Resume_1 = require("./Resume");
-function elem(item, url, is_ref, is_fill, text_width, font, margin, alignment, width, background_color) {
+const marked = __importStar(require("marked"));
+const ts_pattern_1 = require("ts-pattern");
+const Utils_1 = require("./Utils");
+function defaultSpanProps() {
+    return {
+        is_italic: false,
+        is_bold: false,
+        is_code: false,
+        is_link: false,
+    };
+}
+function elem(item, url, is_ref, is_fill, is_markdown, text_width, font, margin, alignment, width, background_color) {
     return {
         tag: "Elem",
         item,
         url,
         is_ref,
         is_fill,
+        is_markdown,
         text_width,
         font,
         margin,
@@ -55,6 +67,7 @@ function default_() {
         url: null,
         is_ref: false,
         is_fill: false,
+        is_markdown: false,
         text_width: _1.Width.default_(),
         font: Font.default_(),
         margin: _1.Margin.default_(),
@@ -64,10 +77,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -120,13 +129,94 @@ function scaleWidth(e, scale) {
     return withWidth(e, _1.Width.scale(e.width, scale));
 }
 exports.scaleWidth = scaleWidth;
+function flatten(ts, sp) {
+    const spans = [];
+    for (const t of ts) {
+        spans.push(...flattenToken(t, sp));
+    }
+    return spans;
+}
+function flattenToken(t, sp) {
+    return (0, ts_pattern_1.match)(t)
+        .returnType()
+        .with({ type: "paragraph", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, sp);
+    })
+        .with({ type: "strong", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, { ...sp, is_bold: true });
+    })
+        .with({ type: "em", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, { ...sp, is_italic: true });
+    })
+        .with({ type: "codespan", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        return [{ ...sp, is_code: true, text, link: null }];
+    })
+        .with({ type: "text", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, sp);
+    })
+        .with({ type: "text", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        const result = [];
+        if (text.startsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        result.push({ ...sp, text: text.trim(), link: null });
+        if (text.endsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        else if (text.endsWith("\n")) {
+            result.push({ ...sp, text: "\n", link: null });
+        }
+        return result;
+    })
+        .otherwise((e) => {
+        // console.log(`Unknown token type: ${JSON.stringify(e)}`);
+        return [{ ...defaultSpanProps(), text: e.raw, link: null }];
+    });
+}
+function parseMarkdownItem(item) {
+    const spans = [];
+    for (const token of marked.lexer(item)) {
+        spans.push(...flatten([token], defaultSpanProps()));
+    }
+    return spans;
+}
+exports.parseMarkdownItem = parseMarkdownItem;
 function fillFonts(e, fonts) {
-    const text_width_with_font = Font.get_width(e.font, e.item, fonts);
+    const simpleSpans = e.is_markdown ? parseMarkdownItem(e.text) : [{ ...defaultSpanProps(), text: e.text, font: e.font, link: null }];
+    const spans = [];
+    for (const span of simpleSpans) {
+        const font = e.is_markdown ? (0, Utils_1.with_)(e.font, ({
+            // style: span.is_italic ? "Italic" : "Normal",
+            weight: span.is_bold ? "Bold" : "Medium",
+        })) : e.font;
+        if (span.text === " ") {
+            const width = Font.get_width(font, "-", fonts);
+            spans.push({ ...span, font, width });
+            continue;
+        }
+        if (span.text === "\n\n") {
+            spans.push({ ...span, font, width: 0 });
+            continue;
+        }
+        const words = span.text.split(/\s+/);
+        words.forEach((word, index) => {
+            const width = Font.get_width(font, word, fonts);
+            spans.push({ ...span, text: word, font, width });
+            if (index < words.length - 1) {
+                spans.push({ ...span, text: " ", font, width: Font.get_width(font, " ", fonts) });
+            }
+        });
+    }
+    const text_width = spans.reduce((acc, span) => acc + span.width, 0);
     if (e.is_fill) {
-        return withTextWidth(withWidth(e, _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width_with_font))), _1.Width.absolute(text_width_with_font));
+        return (0, Utils_1.with_)(e, {
+            width: _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width)),
+            text_width: _1.Width.absolute(text_width),
+            spans
+        });
     }
     else {
-        return withTextWidth(e, _1.Width.absolute(text_width_with_font));
+        return (0, Utils_1.with_)(e, { text_width: _1.Width.absolute(text_width), spans });
     }
 }
 exports.fillFonts = fillFonts;
@@ -137,7 +227,7 @@ function justifiedLines(e, lines, font_dict) {
         const r = (0, Row_1.row)([], line.margin, line.alignment, line.width, false, false);
         words.forEach(word => {
             const word_width = Font.get_width(e.font, word, font_dict);
-            r.elements.push(elem(word, null, false, false, _1.Width.absolute(word_width), this.font, _1.Margin.default_(), _1.Alignment.default_(), _1.Width.absolute(word_width), this.background_color));
+            r.elements.push(elem(word, null, false, false, false, _1.Width.absolute(word_width), this.font, _1.Margin.default_(), _1.Alignment.default_(), _1.Width.absolute(word_width), this.background_color));
         });
         rowLines.push(Row_1.row);
     }
@@ -152,7 +242,7 @@ function break_lines(e, font_dict) {
     const lines = [];
     // todo: I'm sure this implementation is pretty buggy. Note to future me, fix
     // this.
-    const words = e.item.split(/\s+/);
+    const words = e.text.split(/\s+/);
     const widths = words.map((word) => Font.get_width(e.font, word, font_dict));
     const space_width = Font.get_width(e.font, " ", font_dict);
     let start = 0;
@@ -189,20 +279,25 @@ function boundWidth(e, width) {
     }
 }
 exports.boundWidth = boundWidth;
-function instantiate(e, section) {
+function instantiate(e, section, fields) {
     if (!e.is_ref) {
         return e;
     }
+    const itemType = fields.find(f => f.name === e.item);
+    if (itemType.type.tag === "MarkdownString") {
+        e.is_markdown = true;
+    }
     const text = section.get(e.item);
+    console.log(`Instantiating ${e.item} with ${JSON.stringify(text)}`);
     if (text === undefined) {
-        return withIsRef(withItem(e, ""), false);
+        return (0, Utils_1.with_)(e, { is_ref: false, text: "" });
     }
     else {
         if (text.tag === "Url") {
-            return withIsRef(withUrl(withItem(e, text.value.text), text.value.url), false);
+            return (0, Utils_1.with_)(e, { is_ref: false, text: text.value.text, url: text.value.url });
         }
         else {
-            return withIsRef(withItem(e, Resume_1.ItemContent.toString(text)), false);
+            return (0, Utils_1.with_)(e, { is_ref: false, text: Resume_1.ItemContent.toString(text) });
         }
     }
 }

package/dist/Layout.d.ts

@@ -4,11 +4,12 @@ import * as Width from "./Width";
 import * as Font from "./Font";
 import { ItemContent } from "./Resume";
 import { Box } from "./Box";
-import { FontDict } from "./AnyLayout";
+import { ElementPath, FontDict } from "./AnyLayout";
 import { Point } from "./Point";
 import * as Stack from "./Stack";
 import * as Row from "./Row";
 import * as Elem from "./Elem";
+import { Field } from "./DataSchema";
 export type Container = Stack.t | Row.t;
 export type t = Stack.t | Row.t | Elem.t;
 type Layout = t;
@@ -23,7 +24,9 @@ export type RenderedRow = Row.t & {
 export type RenderedElem = Elem.t & {
     bounding_box: Box;
 };
-export type RenderedLayout = RenderedStack | RenderedRow | RenderedElem;
+export type RenderedLayout = (RenderedStack | RenderedRow | RenderedElem) & {
+    path?: ElementPath;
+};
 export declare function default_(tag: string): Stack.t | Row.t | Elem.t;
 export declare function empty(): Layout;
 export declare function fromJson(json: unknown): Layout;
@@ -39,7 +42,7 @@ export declare function withAlignment(l: Layout, alignment: Alignment.t): Layout
 export declare function withWidth(l: Layout, width: Width.t): Layout;
 export declare function totalElementsWidth(l: Layout): number;
 export declare function isInstantiated(l: Layout): boolean;
-export declare function instantiate(l: Layout, section: Map<string, ItemContent>): Layout;
+export declare function instantiate(l: Layout, section: Map<string, ItemContent>, fields: Field.t[]): Layout;
 export declare function boundWidth(l: Layout, width: number): Layout;
 export declare function scaleWidth(l: Layout, document_width: number): Layout;
 export declare function normalize(l: Layout, width: number, font_dict: FontDict): Layout;

package/dist/Layout.js

@@ -63,6 +63,7 @@ function fromJson(json) {
         case 'Text': {
             const inner = default_(key);
             inner.item = json[key].item;
+            inner.text = json[key].item;
             inner.margin = json[key].margin;
             inner.alignment = json[key].alignment;
             inner.width = Width.fromJson(json[key].width);
@@ -209,14 +210,14 @@ function isInstantiated(l) {
     }
 }
 exports.isInstantiated = isInstantiated;
-function instantiate(l, section) {
+function instantiate(l, section, fields) {
     switch (l.tag) {
         case "Stack":
-            return Stack.instantiate(l, section);
+            return Stack.withElements(l, l.elements.map(e => instantiate(e, section, fields)));
         case "Row":
-            return Row.instantiate(l, section);
+            return Row.withElements(l, l.elements.map(e => instantiate(e, section, fields)));
         case "Elem":
-            return Elem.instantiate(l, section);
+            return Elem.instantiate(l, section, fields);
     }
 }
 exports.instantiate = instantiate;
@@ -266,9 +267,10 @@ function normalize(l, width, font_dict) {
     console.debug("Widths are bounded. Filling fonts...");
     const font_filled_layout = fillFonts(bounded_layout, font_dict);
     console.debug("Fonts filled. Breaking lines...");
-    const broken_layout = breakLines(font_filled_layout, font_dict);
+    // const broken_layout = breakLines(font_filled_layout, font_dict);
     console.debug("Lines broken.");
-    return broken_layout;
+    // return broken_layout;
+    return font_filled_layout;
 }
 exports.normalize = normalize;
 function fillFonts(l, font_dict) {
@@ -354,7 +356,11 @@ function computeTextboxPositions(l, top_left, font_dict) {
                 top_left = top_left.move_y_to(depth);
                 renderedElements.push(result.renderedLayout);
             }
-            return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(originalTopLeft, top_left.move_x_by(Width.get_fixed_unchecked(stack.width))), elements: renderedElements } };
+            return {
+                depth, renderedLayout: {
+                    ...l, bounding_box: new Box_1.Box(originalTopLeft, top_left.move_x_by(Width.get_fixed_unchecked(stack.width))), elements: renderedElements
+                }
+            };
         }
         case "Row": {
             const row = l;
@@ -380,29 +386,41 @@ function computeTextboxPositions(l, top_left, font_dict) {
                     top_left.move_x_by(Width.get_fixed_unchecked(element.width) + per_elem_space);
                 renderedElements.push(result.renderedLayout);
             }
-            return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(originalTopLeft, originalTopLeft.move_y_by(depth).move_x_by(Width.get_fixed_unchecked(row.width))), elements: renderedElements } };
+            return {
+                depth, renderedLayout: {
+                    ...l, bounding_box: new Box_1.Box(originalTopLeft, originalTopLeft.move_y_by(depth).move_x_by(Width.get_fixed_unchecked(row.width))), elements: renderedElements
+                }
+            };
         }
         case "Elem": {
             const elem = l;
             if (elem.is_ref) {
                 throw new Error("Cannot compute textbox positions of uninstantiated layout");
             }
-            if (elem.item === "") {
-                return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(top_left, top_left) } };
-            }
             const height = Font.get_height(elem.font, font_dict);
             const width = Width.get_fixed_unchecked(elem.text_width);
             top_left = top_left.move_y_by(elem.margin.top).move_x_by(elem.margin.left);
-            switch (elem.alignment) {
-                case "Center":
-                    top_left = top_left.move_x_by((Width.get_fixed_unchecked(elem.width) - width) / 2.0);
-                    break;
-                case "Right":
-                    top_left = top_left.move_x_by(Width.get_fixed_unchecked(elem.width) - width);
-                    break;
-            }
-            const textbox = new Box_1.Box(top_left, top_left.move_x_by(width).move_y_by(height));
-            return { depth: top_left.y + height, renderedLayout: { ...l, bounding_box: textbox } };
+            let line = 1;
+            let cursor = top_left.x;
+            elem.spans.forEach(span => {
+                if (cursor - top_left.x + span.width > Width.get_fixed_unchecked(elem.width) - elem.margin.right || span.text === "\n\n") {
+                    cursor = top_left.x;
+                    line += 1;
+                }
+                span.bbox = new Box_1.Box(new Point_1.Point(cursor - top_left.x, (line - 1) * height), new Point_1.Point(cursor + span.width, line * height));
+                span.line = line;
+                cursor += span.width;
+            });
+            // switch (elem.alignment) {
+            //     case "Center":
+            //         top_left = top_left.move_x_by((Width.get_fixed_unchecked(elem.width) - width) / 2.0);
+            //         break;
+            //     case "Right":
+            //         top_left = top_left.move_x_by(Width.get_fixed_unchecked(elem.width) - width);
+            //         break;
+            // }
+            const textbox = new Box_1.Box(top_left, top_left.move_x_by(width).move_y_by(height * line));
+            return { depth: top_left.y + height * line, renderedLayout: { ...l, bounding_box: textbox } };
         }
     }
 }

package/dist/PdfLayout.d.ts

@@ -5,6 +5,7 @@ import { DataSchema } from "./DataSchema";
 import { LayoutSchema } from "./LayoutSchema";
 import { ResumeLayout } from "./ResumeLayout";
 import { Storage } from "./Storage";
+import * as Elem from "./Elem";
 import { Layout } from ".";
 export type RenderResult = {
     blob: Blob;
@@ -20,5 +21,6 @@ export type RenderProps = {
     fontDict?: FontDict;
     debug: boolean;
 };
-export declare const render: ({ resume_name, resume, data_schemas, layout_schemas, resume_layout, storage, fontDict, debug }: RenderProps) => Promise<RenderResult>;
+export declare const render: ({ resume_name, resume, data_schemas, layout_schemas, resume_layout, storage, fontDict }: RenderProps) => Promise<RenderResult>;
+export declare const mergeSpans: (spans: Elem.Span[]) => Elem.Span[];
 export declare const renderSectionLayout: (layout: Layout.RenderedLayout, resume_layout: ResumeLayout, current_height: number, doc: PDFKit.PDFDocument) => void;

package/dist/PdfLayout.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderSectionLayout = exports.render = void 0;
+exports.renderSectionLayout = exports.mergeSpans = exports.render = void 0;
 const blob_stream_1 = __importDefault(require("blob-stream"));
 const AnyLayout_1 = require("./AnyLayout");
 const pdfkit_1 = __importDefault(require("pdfkit"));
 const _1 = require(".");
-const render = async ({ resume_name, resume, data_schemas, layout_schemas, resume_layout, storage, fontDict, debug = false }) => {
+const render = async ({ resume_name, resume, data_schemas, layout_schemas, resume_layout, storage, fontDict }) => {
     let start_time = Date.now();
     if (!resume && !resume_name) {
         throw "Rendering requires either resume_name or resume";
@@ -37,7 +37,7 @@ const render = async ({ resume_name, resume, data_schemas, layout_schemas, resum
     // doc.pipe(fs.createWriteStream('output.pdf'));
     const stream = doc.pipe((0, blob_stream_1.default)());
     start_time = Date.now();
-    const [font_dict, layouts] = await (0, AnyLayout_1.render)({ layout_schemas, resume, data_schemas, resume_layout, storage, fontDict });
+    const layouts = await (0, AnyLayout_1.render)({ layout_schemas, resume, data_schemas, resume_layout, storage, fontDict });
     end_time = Date.now();
     console.info(`Rendering time: ${end_time - start_time}ms`);
     console.log("Constructing printpdf font dictionary...");
@@ -46,7 +46,7 @@ const render = async ({ resume_name, resume, data_schemas, layout_schemas, resum
     //     "/Users/akeles/Programming/projects/cvdl/cvdl/assets/Exo/static/Exo-Medium.ttf");
     try {
         console.log("Registering fonts...");
-        for (const [font_name, font] of font_dict.fonts.entries()) {
+        for (const [font_name, font] of fontDict.fonts.entries()) {
             console.log(`Registering font ${font_name}`);
             // @ts-ignore
             doc.registerFont(font_name, font.stream.buffer);
@@ -56,36 +56,16 @@ const render = async ({ resume_name, resume, data_schemas, layout_schemas, resum
         console.error(e);
     }
     console.log("Rendering the document...");
-    // Render the boxes
-    // for (const [index, boxes] of pages.entries()) {
-    //     if (index > 0) {
-    //         doc.addPage();
-    //     }
-    //     boxes.forEach((box) => {
-    //         const elements = box.elements;
-    //         // if (debug) {
-    //         //     doc.rect(box.bounding_box.top_left.x, box.bounding_box.top_left.y, box.bounding_box.width(), box.bounding_box.height()).stroke();
-    //         // }
-    //         for (const [box_, element] of elements) {
-    //             console.log(
-    //                 `(${box_.top_left.x}, ${box_.top_left.y})(${box_.bottom_right.x}, ${box_.bottom_right.y}): ${element.item}`
-    //             );
-    //             if (element.background_color !== "Transparent") {
-    //                 doc.rect(box_.top_left.x, box_.top_left.y, box_.width(), box_.height()).fillAndStroke(ColorMap[element.background_color], ColorMap[element.background_color]);
-    //             }
-    //             // Make this more generic
-    //             doc.fillColor("black");
-    //             doc.
-    //                 font(element.font.full_name()).
-    //                 fontSize(element.font.size).
-    //                 text(element.item, box_.top_left.x, box_.top_left.y, { lineBreak: false });
-    //             if (debug) {
-    //                 // doc.rect(box_.top_left.x, box_.top_left.y, box_.width(), box_.height()).stroke();
-    //             }
-    //         }
-    //     });
-    // }
     let current_height = 0;
+    // Add rulers to the document at every 10 pixels
+    doc.strokeColor("grey");
+    for (let i = 0; i < resume_layout.height; i += 10) {
+        doc.moveTo(0, i).lineTo(resume_layout.width, i).stroke();
+    }
+    for (let i = 0; i < resume_layout.width; i += 10) {
+        doc.moveTo(i, 0).lineTo(i, resume_layout.height).stroke();
+    }
+    doc.strokeColor("black");
     for (const layout of layouts) {
         (0, exports.renderSectionLayout)(layout, resume_layout, current_height, doc);
         current_height += layout.bounding_box.height() + layout.margin.top + layout.margin.bottom;
@@ -103,6 +83,27 @@ const render = async ({ resume_name, resume, data_schemas, layout_schemas, resum
     });
 };
 exports.render = render;
+const mergeSpans = (spans) => {
+    const merged_spans = [];
+    let currentSpan = spans[0];
+    for (let i = 1; i < spans.length; i++) {
+        if (currentSpan.bbox.top_left.y === spans[i].bbox.top_left.y
+            && currentSpan.font === spans[i].font
+            && currentSpan.is_code === spans[i].is_code
+            && currentSpan.is_bold === spans[i].is_bold
+            && currentSpan.is_italic === spans[i].is_italic) {
+            currentSpan.text += spans[i].text;
+            currentSpan.bbox.bottom_right = spans[i].bbox.bottom_right;
+        }
+        else {
+            merged_spans.push(currentSpan);
+            currentSpan = spans[i];
+        }
+    }
+    merged_spans.push(currentSpan);
+    return merged_spans;
+};
+exports.mergeSpans = mergeSpans;
 const renderSectionLayout = (layout, resume_layout, current_height, doc) => {
     switch (layout.tag) {
         case "Stack": {
@@ -121,10 +122,31 @@ const renderSectionLayout = (layout, resume_layout, current_height, doc) => {
         }
         case "Elem": {
             const elem = layout;
-            doc.
-                font(_1.Font.full_name(elem.font)).
-                fontSize(elem.font.size).
-                text(elem.item, layout.bounding_box.top_left.x + resume_layout.margin.left, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height, { lineBreak: false });
+            elem.spans.forEach((span) => {
+                console.log("Rendering span:", span);
+                doc.
+                    font(_1.Font.full_name(span.font)).
+                    fontSize(span.font.size).
+                    text(span.text, layout.bounding_box.top_left.x
+                    + resume_layout.margin.left
+                    + span.bbox.top_left.x, layout.bounding_box.top_left.y
+                    + resume_layout.margin.top
+                    + current_height
+                    + span.bbox.top_left.y, { lineBreak: false });
+                if (span.is_code) {
+                    // Add a rounded rectangle around the code
+                    doc.roundedRect(layout.bounding_box.top_left.x + resume_layout.margin.left + span.bbox.top_left.x - span.font.size / 5, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height + span.bbox.top_left.y, span.bbox.width() + span.font.size / 5 * 2, span.bbox.height(), 5).stroke();
+                    // Add a background color to the code
+                    doc.fillColor("black");
+                    doc.fillOpacity(0.05);
+                    doc.rect(layout.bounding_box.top_left.x + resume_layout.margin.left + span.bbox.top_left.x - span.font.size / 5, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height + span.bbox.top_left.y, span.bbox.width() + span.font.size / 5 * 2, span.bbox.height()).fill();
+                    doc.fillOpacity(1);
+                }
+            });
+            // doc.
+            //     font(Font.full_name(elem.font)).
+            //     fontSize(elem.font.size).
+            //     text(elem.item, layout.bounding_box.top_left.x + resume_layout.margin.left, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height, { lineBreak: false });
             break;
         }
     }

package/dist/Row.d.ts

@@ -1,8 +1,7 @@
 import { Alignment, Margin, Width } from ".";
 import { FontDict } from "./AnyLayout";
-import { Optional } from "./Elem";
+import { Optional } from "./Utils";
 import * as Layout from "./Layout";
-import { ItemContent } from "./Resume";
 export type t = {
     tag: "Row";
     elements: Layout.t[];
@@ -13,12 +12,10 @@ export type t = {
     is_fill: boolean;
 };
 type Row = t;
-export declare function with_(e: Row, w: Optional<Row>): Row;
 export declare function from(w: Optional<Row>): Row;
 export declare function row(elements: Layout.t[], margin: Margin.t, alignment: Alignment.t, width: Width.t, is_frozen: boolean, is_fill: boolean): Row;
 export declare function copy(r: Row): Row;
 export declare function default_(): Row;
-export declare function instantiate(r: Row, section: Map<string, ItemContent>): Row;
 export declare function withElements(r: Row, elements: Layout.t[]): Row;
 export declare function withMargin(r: Row, margin: Margin.t): Row;
 export declare function withAlignment(r: Row, alignment: Alignment.t): Row;

package/dist/Row.js

@@ -23,13 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.breakLines = exports.scaleWidth = exports.boundWidth = exports.elementsWidth = exports.withFill = exports.withFrozen = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.instantiate = exports.default_ = exports.copy = exports.row = exports.from = exports.with_ = void 0;
+exports.breakLines = exports.scaleWidth = exports.boundWidth = exports.elementsWidth = exports.withFill = exports.withFrozen = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.default_ = exports.copy = exports.row = exports.from = void 0;
 const _1 = require(".");
 const Layout = __importStar(require("./Layout"));
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -64,10 +60,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function instantiate(r, section) {
-    return withElements(r, r.elements.map(e => Layout.instantiate(e, section)));
-}
-exports.instantiate = instantiate;
 function withElements(r, elements) {
     return {
         ...r,

package/dist/Stack.d.ts

@@ -1,6 +1,5 @@
 import { Alignment, Layout, Margin, Width } from ".";
-import { Optional } from "./Elem";
-import { ItemContent } from "./Resume";
+import { Optional } from "./Utils";
 export type t = {
     tag: "Stack";
     elements: Layout.t[];
@@ -10,12 +9,10 @@ export type t = {
     is_fill: boolean;
 };
 type Stack = t;
-export declare function with_(e: Stack, w: Optional<Stack>): Stack;
 export declare function from(w: Optional<Stack>): Stack;
 export declare function stack(elements: Layout.t[], margin: Margin.t, alignment: Alignment.t, width: Width.t, is_fill: boolean): Stack;
 export declare function copy(s: Stack): Stack;
 export declare function default_(): Stack;
-export declare function instantiate(s: Stack, section: Map<string, ItemContent>): Stack;
 export declare function withElements(s: Stack, elements: Layout.t[]): Stack;
 export declare function withMargin(s: Stack, margin: Margin.t): Stack;
 export declare function withAlignment(s: Stack, alignment: Alignment.t): Stack;

package/dist/Stack.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaleWidth = exports.boundWidth = exports.withIsFill = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.instantiate = exports.default_ = exports.copy = exports.stack = exports.from = exports.with_ = void 0;
+exports.scaleWidth = exports.boundWidth = exports.withIsFill = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.default_ = exports.copy = exports.stack = exports.from = void 0;
 const _1 = require(".");
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -38,10 +34,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function instantiate(s, section) {
-    return withElements(s, s.elements.map(e => _1.Layout.instantiate(e, section)));
-}
-exports.instantiate = instantiate;
 function withElements(s, elements) {
     return {
         ...s,

package/dist/Utils.d.ts

@@ -0,0 +1,5 @@
+export type Optional<T> = {
+    [P in keyof T]?: T[P];
+};
+export declare function with_<T>(e: T, w: Optional<T>): T;
+export declare const EPSILON = 5;

package/dist/Utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EPSILON = exports.with_ = void 0;
+function with_(e, w) {
+    return { ...e, ...w };
+}
+exports.with_ = with_;
+exports.EPSILON = 5;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cvdl-ts",
-    "version": "1.0.12",
+    "version": "1.0.14",
     "description": "Typescript Implementation of CVDL Compiler",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -13,13 +13,19 @@
         "@types/pdfkit": "^0.13.1",
         "blob-stream": "^0.1.3",
         "fontkit": "^2.0.2",
-        "pdfkit": "^0.13.0"
+        "marked": "^13.0.2",
+        "pdfkit": "^0.13.0",
+        "ts-pattern": "^5.2.0"
     },
     "devDependencies": {
+        "@eslint/compat": "^1.1.1",
+        "@eslint/js": "^9.7.0",
         "@types/node": "^20.8.7",
         "@typescript-eslint/eslint-plugin": "^6.8.0",
         "@typescript-eslint/parser": "^6.8.0",
-        "eslint": "^8.52.0"
+        "eslint-plugin-react": "^7.34.4",
+        "globals": "^15.8.0",
+        "typescript-eslint": "^7.16.1"
     },
     "scripts": {
         "lint": "eslint . --ext .ts",