cvdl-ts 1.0.19 → 1.0.20

package/dist/AnyLayout.d.ts

@@ -1,10 +1,10 @@
 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 Layout from "./Layout";
+import * as Resume from "./Resume";
 export type ElementPath = {
     tag: "none";
 } | {
@@ -21,17 +21,18 @@ export type ElementPath = {
     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

@@ -27,28 +27,26 @@ 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);
+    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.error(`Font ${fontName} is already loaded`);
-                continue;
+                console.log(`Font ${fontName} is already loaded`);
+                return;
             }
-            try {
-                const font_data = await storage.load_font(font);
-                const fontkit_font = fontkit.create(font_data);
-                this.fonts.set(fontName, fontkit_font);
-            }
-            catch (e) {
-                console.error(`Error loading font ${fontName}: ${e}`);
-            }
-        }
+            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);
@@ -59,7 +57,7 @@ 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);
@@ -68,6 +66,7 @@ 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) {
         // Render Section Header
         // 1. Find the layout schema for the section
@@ -77,7 +76,7 @@ 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 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
@@ -87,7 +86,7 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         }
         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);
+        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);
@@ -97,7 +96,7 @@ 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);
+            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);
         }

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 = [
@@ -40,113 +40,10 @@ var DateFormat;
         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;