cvdl-ts 1.0.18 → 1.0.20

package/dist/Alignment.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default_ = void 0;
+exports.default_ = default_;
 function default_() {
     return "Left";
 }
-exports.default_ = default_;

package/dist/AnyLayout.d.ts

@@ -1,37 +1,38 @@
 import { DataSchema } from "./DataSchema";
 import { LayoutSchema } from "./LayoutSchema";
 import { Storage } from "./Storage";
-import { Resume } from "./Resume";
 import { ResumeLayout } from "./ResumeLayout";
-import * as fontkit from 'fontkit';
-import { Layout } from ".";
+import * as fontkit from "fontkit";
+import * as Layout from "./Layout";
+import * as Resume from "./Resume";
 export type ElementPath = {
-    tag: 'none';
+    tag: "none";
 } | {
-    tag: 'section';
+    tag: "section";
     section: string;
 } | {
-    tag: 'item';
+    tag: "item";
     section: string;
     item: number;
 } | {
-    tag: 'field';
+    tag: "field";
     section: string;
     item: number;
     field: string;
 };
 export type RenderProps = {
-    resume: Resume;
+    resume: Resume.t;
     layout_schemas: LayoutSchema[];
-    data_schemas: DataSchema[];
+    data_schemas: DataSchema.t[];
     resume_layout: ResumeLayout;
+    bindings: Map<string, unknown>;
     storage: Storage;
     fontDict?: FontDict;
 };
 export declare class FontDict {
     fonts: Map<string, fontkit.Font>;
     constructor();
-    load_fonts_from_schema(schema: LayoutSchema, storage: Storage): Promise<void>;
+    load_fonts(storage: Storage): Promise<this>;
     get_font(name: string): fontkit.Font;
 }
-export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }: RenderProps): Promise<Layout.RenderedLayout[]>;
+export declare function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, fontDict, }: RenderProps): Promise<Layout.RenderedLayout[]>;

package/dist/AnyLayout.js

@@ -23,26 +23,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.render = exports.FontDict = void 0;
+exports.FontDict = void 0;
+exports.render = render;
 const ResumeLayout_1 = require("./ResumeLayout");
 const fontkit = __importStar(require("fontkit"));
-const _1 = require(".");
+const Layout = __importStar(require("./Layout"));
+const cartesian = (...a) => a.reduce((a, b) => a.flatMap(d => b.map(e => [d, e].flat())));
 class FontDict {
     constructor() {
         this.fonts = new Map();
     }
-    async load_fonts_from_schema(schema, storage) {
-        for (const font of schema.fonts()) {
-            const fontName = _1.Font.full_name(font);
-            console.log(`Loading font ${fontName}`);
+    async load_fonts(storage) {
+        const variants = cartesian(["Exo", "OpenSans", "SourceCodePro"], ["Medium", "Bold"], ["", "Italic"]);
+        await Promise.all(variants.map(async ([name, weight, style]) => {
+            const fontName = `${name}-${weight}${style}`;
+            console.error(`Loading font ${fontName}`);
             if (this.fonts.has(fontName)) {
                 console.log(`Font ${fontName} is already loaded`);
-                continue;
+                return;
             }
-            const font_data = await storage.load_font(font);
+            const font_data = await storage.load_font(fontName);
             const fontkit_font = fontkit.create(font_data);
             this.fonts.set(fontName, fontkit_font);
-        }
+        }));
+        return this;
     }
     get_font(name) {
         const font = this.fonts.get(name);
@@ -53,37 +57,37 @@ class FontDict {
     }
 }
 exports.FontDict = FontDict;
-async function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }) {
+async function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, 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);
+    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
     const column_width = resume_layout.column_type.tag === "SingleColumn"
         ? width
-        : (width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0);
+        : width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0;
     const layouts = [];
     console.error("Rendering sections...");
     for (const section of resume.sections) {
         // Render Section Header
         // 1. Find the layout schema for the section
         console.info("Computing section: ", section.section_name);
-        const layout_schema = layout_schemas
-            .find(s => s.schema_name === section.layout_schema);
+        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}`);
         }
         let start_time = Date.now();
-        await fontDict.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);
+        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, data_schema.header_schema), column_width, fontDict), fontDict);
-        layout.path = { tag: 'section', section: section.section_name };
+        const layout = Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema, bindings), column_width, fontDict), fontDict);
+        layout.path = { tag: "section", section: section.section_name };
         console.info("Header is computed");
         layouts.push(layout);
         end_time = Date.now();
@@ -92,8 +96,8 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         // Render Section Items
         for (const [index, item] of section.items.entries()) {
             // 3. Render the item
-            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 };
+            const layout = Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.item_layout_schema, item, data_schema.item_schema, bindings), column_width, fontDict), fontDict);
+            layout.path = { tag: "item", section: section.section_name, item: index };
             layouts.push(layout);
         }
         end_time = Date.now();
@@ -102,4 +106,3 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
     console.log("Position calculations are completed.");
     return layouts;
 }
-exports.render = render;

package/dist/DataSchema.d.ts

@@ -32,27 +32,16 @@ export declare namespace DocumentDataType {
     };
     type t = Date | PureString | MarkdownString | PureNumber | Type | List | Types;
     type DocumentDataType = t;
-    function parse(s: string): DocumentDataType;
-    function print(d: DocumentDataType): string;
 }
-export declare namespace Field {
+export type Field = {
+    name: string;
+    type: DocumentDataType.t;
+};
+export declare namespace DataSchema {
     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.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: unknown[];
-        item_schema: unknown[];
+        header_schema: Field[];
+        item_schema: Field[];
     };
+    function dataSchema(schema_name: string, header_schema: Field[], item_schema: Field[]): t;
 }

package/dist/DataSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSchema = exports.Field = exports.DocumentDataType = exports.DateFormat = void 0;
+exports.DataSchema = exports.DateFormat = void 0;
 var DateFormat;
 (function (DateFormat) {
     DateFormat.formats = [
@@ -16,10 +16,9 @@ var DateFormat;
         "Mon YYYY",
         "Mon DD, YYYY",
         "YYYY",
-        "unknown"
+        "unknown",
     ];
     DateFormat.print = (date, format) => {
-        console.error(date);
         const d = new Date(date + "T00:00:00");
         const year = d.getFullYear();
         const month = d.getMonth() + 1;
@@ -29,115 +28,22 @@ var DateFormat;
         result = result.replace("YY", year.toString().slice(-2));
         result = result.replace("MM", month.toString().padStart(2, "0"));
         result = result.replace("DD", day.toString().padStart(2, "0"));
-        result = result.replace("Month", d.toLocaleString('default', { month: 'long' }));
-        result = result.replace("Mon", d.toLocaleString('default', { month: 'short' }));
+        result = result.replace("Month", d.toLocaleString("default", { month: "long" }));
+        result = result.replace("Mon", d.toLocaleString("default", { month: "short" }));
         return result;
     };
     DateFormat.parse = (date) => {
         const d = new Date(date + "T00:00:00");
-        console.error(d);
         if (isNaN(d.getTime())) {
             return "";
         }
         return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
     };
 })(DateFormat || (exports.DateFormat = DateFormat = {}));
-var DocumentDataType;
-(function (DocumentDataType) {
-    function parse(s) {
-        if (s === "Date") {
-            return { tag: "Date", format: s.length > 4 ? s.slice(5, -1).trim() : "YYYY-MM-DD" };
-        }
-        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;
-        this.header_schema = header_schema;
-        this.item_schema = item_schema;
-    }
-    static fromJson(json) {
-        if (typeof json !== "object" || json === null) {
-            throw new Error("DataSchema must be an object");
-        }
-        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.map(Field.fromJson), json.item_schema.map(Field.fromJson));
-    }
-    toJson() {
-        return {
-            schema_name: this.schema_name,
-            header_schema: this.header_schema.map(Field.toJson),
-            item_schema: this.item_schema.map(Field.toJson),
-        };
+var DataSchema;
+(function (DataSchema) {
+    function dataSchema(schema_name, header_schema, item_schema) {
+        return { schema_name, header_schema, item_schema };
     }
-}
-exports.DataSchema = DataSchema;
+    DataSchema.dataSchema = dataSchema;
+})(DataSchema || (exports.DataSchema = DataSchema = {}));

package/dist/Defaults.d.ts

@@ -0,0 +1,35 @@
+import { DataSchema } from "./DataSchema";
+import { LayoutSchema } from "./LayoutSchema";
+import { ResumeLayout } from "./ResumeLayout";
+import * as Resume from "./Resume";
+import { ResumeSection } from "./Resume";
+export declare const Basics: DataSchema.t;
+export declare const BasicsLayout: LayoutSchema;
+export declare const Work: DataSchema.t;
+export declare const WorkLayout: LayoutSchema;
+export declare const Volunteer: DataSchema.t;
+export declare const VolunteerLayout: LayoutSchema;
+export declare const Education: DataSchema.t;
+export declare const EducationLayout: LayoutSchema;
+export declare const Awards: DataSchema.t;
+export declare const AwardsLayout: LayoutSchema;
+export declare const Certificates: DataSchema.t;
+export declare const CertificatesLayout: LayoutSchema;
+export declare const Publications: DataSchema.t;
+export declare const PublicationsLayout: LayoutSchema;
+export declare const Skills: DataSchema.t;
+export declare const SkillsLayout: LayoutSchema;
+export declare const Languages: DataSchema.t;
+export declare const LanguagesLayout: LayoutSchema;
+export declare const Interests: DataSchema.t;
+export declare const InterestsLayout: LayoutSchema;
+export declare const References: DataSchema.t;
+export declare const ReferencesLayout: LayoutSchema;
+export declare const Projects: DataSchema.t;
+export declare const ProjectsLayout: LayoutSchema;
+export declare const DefaultDataSchemas: DataSchema.t[];
+export declare const DefaultLayoutSchemas: LayoutSchema[];
+export declare const DefaultBindings: Map<string, unknown>;
+export declare const DefaultResumeLayout: ResumeLayout;
+export declare const DefaultSections: ResumeSection.t[];
+export declare const DefaultResume: Resume.t;