cvdl-ts 1.0.11 → 1.0.13

package/dist/AnyLayout.d.ts

@@ -1,11 +1,10 @@
-import { Box } from "./Box";
 import { DataSchema } from "./DataSchema";
-import { Elem, SectionLayout } from "./Layout";
 import { LayoutSchema } from "./LayoutSchema";
 import { Storage } from "./Storage";
 import { Resume } from "./Resume";
 import { ResumeLayout } from "./ResumeLayout";
 import * as fontkit from 'fontkit';
+import { Layout } from ".";
 export type ElementPath = {
     tag: 'none';
 } | {
@@ -21,14 +20,6 @@ export type ElementPath = {
     item: number;
     field: string;
 };
-export declare class ElementBox {
-    bounding_box: Box;
-    elements: [Box, Elem][];
-    path?: ElementPath;
-    constructor(bounding_box: Box, elements: [Box, Elem][]);
-    move_y_by(y: number): ElementBox;
-    move_x_by(x: number): ElementBox;
-}
 export type RenderProps = {
     resume: Resume;
     layout_schemas: LayoutSchema[];
@@ -43,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, ElementBox[][], SectionLayout[]]>;
+export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }: RenderProps): Promise<[FontDict, Layout.RenderedLayout[]]>;

package/dist/AnyLayout.js

@@ -23,45 +23,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.render = exports.FontDict = exports.ElementBox = void 0;
+exports.render = exports.FontDict = void 0;
 const ResumeLayout_1 = require("./ResumeLayout");
 const fontkit = __importStar(require("fontkit"));
-class ElementBox {
-    constructor(bounding_box, elements) {
-        this.bounding_box = bounding_box;
-        this.elements = elements;
-        this.path = { tag: 'none' };
-    }
-    move_y_by(y) {
-        this.bounding_box = this.bounding_box.move_y_by(y);
-        this.elements = this
-            .elements
-            .map(([b, e]) => ([b.move_y_by(y), e]));
-        return this;
-    }
-    move_x_by(x) {
-        this.bounding_box = this.bounding_box.move_x_by(x);
-        this.elements = this
-            .elements
-            .map(([b, e]) => ([b.move_x_by(x), e]));
-        return this;
-    }
-}
-exports.ElementBox = ElementBox;
+const _1 = require(".");
 class FontDict {
     constructor() {
         this.fonts = new Map();
     }
     async load_fonts_from_schema(schema, storage) {
         for (const font of schema.fonts()) {
-            console.log(`Loading font ${font.full_name()}`);
-            if (this.fonts.has(font.full_name())) {
-                console.log(`Font ${font.full_name()} is already loaded`);
+            const fontName = _1.Font.full_name(font);
+            console.log(`Loading font ${fontName}`);
+            if (this.fonts.has(fontName)) {
+                console.log(`Font ${fontName} is already loaded`);
                 continue;
             }
             const font_data = await storage.load_font(font);
             const fontkit_font = fontkit.create(font_data);
-            this.fonts.set(font.full_name(), fontkit_font);
+            this.fonts.set(fontName, fontkit_font);
         }
     }
     get_font(name) {
@@ -75,7 +55,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 boxes = [];
     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);
@@ -84,7 +63,9 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         ? width
         : (width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0);
     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);
@@ -98,81 +79,28 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         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 [result, layout] = layout_schema
-            .header_layout_schema
-            // .copy()
-            .instantiate(section.data)
-            .normalize(column_width, font_dict)
-            .compute_boxes(font_dict);
-        console.error("LSH: ", layout);
+        const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema), column_width, font_dict), font_dict);
+        console.error("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}`);
-        result.path = {
-            tag: 'section',
-            section: section.section_name
-        };
-        boxes.push(result);
         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");
-            // 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);
+        for (const [, item] of section.items.entries()) {
             // 3. Render the item
-            const [result, layout] = layout_schema
-                .item_layout_schema
-                // .copy()
-                .instantiate(item.fields)
-                .normalize(column_width, font_dict)
-                .compute_boxes(font_dict);
-            console.error("LSS: ", layout);
+            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields, data_schema.item_schema), column_width, font_dict), font_dict);
             layouts.push(layout);
-            result.path = {
-                tag: 'item',
-                section: section.section_name,
-                item: index
-            };
-            boxes.push(result);
         }
         end_time = Date.now();
         console.info(`Item rendering time: ${end_time - start_time}ms for section ${section.section_name}`);
     }
-    let current_y = resume_layout.margin.top;
-    let current_x = resume_layout.margin.left;
-    const pages = [];
-    pages.push([]);
-    for (const box of boxes) {
-        if (current_y + box.bounding_box.height() > resume_layout.height) {
-            current_y = resume_layout.margin.top;
-            current_x += column_width + (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type);
-            if (current_x > width) {
-                pages.push([]);
-                current_x = resume_layout.margin.left;
-            }
-        }
-        pages[pages.length - 1].push(box.move_y_by(current_y).move_x_by(current_x));
-        current_y += box.bounding_box.height();
-    }
     console.log("Position calculations are completed.");
-    return [font_dict, pages, layouts];
+    return [font_dict, 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

@@ -0,0 +1,73 @@
+import * as Font from "./Font";
+import { Alignment, Layout, Margin, Width } from ".";
+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";
+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;
+    spans?: Span[];
+    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;
+};
+type Elem = t;
+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;
+    spans?: Span[];
+    url: string;
+    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: Layout.Color;
+};
+export declare function default_(): 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;
+export declare function withIsRef(e: Elem, is_ref: boolean): Elem;
+export declare function asRef(e: Elem): Elem;
+export declare function withIsFill(e: Elem, is_fill: boolean): Elem;
+export declare function withTextWidth(e: Elem, text_width: Width.t): Elem;
+export declare function withFont(e: Elem, font: Font.t): Elem;
+export declare function withMargin(e: Elem, margin: Margin.t): Elem;
+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>, fields: Field.t[]): Elem;
+export {};