cvdl-ts 1.0.2 → 1.0.3

package/dist/AnyLayout.js

@@ -60,7 +60,7 @@ class FontDict {
             }
             console.log(`Source ${font.source}`);
             const font_data = await storage.load_font(font);
-            console.log(font_data);
+            console.error(font_data);
             const fontkit_font = fontkit.create(font_data);
             this.fonts.set(font.full_name(), fontkit_font);
         }
@@ -99,6 +99,7 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         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);
+        console.error(data_schemas);
         if (_data_schema === undefined) {
             throw new Error(`Could not find data schema ${section.data_schema}`);
         }
@@ -135,7 +136,7 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
             const result = layout_schema
                 .item_layout_schema
                 .copy()
-                .instantiate(item)
+                .instantiate(item.fields)
                 .normalize(column_width, font_dict)
                 .compute_boxes(font_dict);
             boxes.push(result);

package/dist/Font.d.ts

@@ -7,6 +7,7 @@ export declare class Font {
     source: FontSource;
     constructor(name: string, size: number, weight: FontWeight, style: FontStyle, source: FontSource);
     static fromJson(json: unknown): Font;
+    toJson(): unknown;
     static default_(): Font;
     full_name(): string;
     get_width(text: string, fonts: FontDict): number;

package/dist/Font.js

@@ -13,15 +13,24 @@ class Font {
         if (typeof json !== "object" || json === null) {
             return Font.default_();
         }
-        const name = ("name" in json) ? json.name : "Arial";
+        const name = ("name" in json) ? json.name : "Exo";
         const size = ("size" in json) ? json.size : 12;
         const weight = ("weight" in json) ? json.weight : "Medium";
         const style = ("style" in json) ? json.style : "Normal";
         const source = ("source" in json) ? json.source : "System";
         return new Font(name, size, weight, style, source);
     }
+    toJson() {
+        return {
+            name: this.name,
+            size: this.size,
+            weight: this.weight,
+            style: this.style,
+            source: this.source
+        };
+    }
     static default_() {
-        return new Font("Arial", 12, "Medium", "Normal", "System");
+        return new Font("Exo", 12, "Medium", "Normal", "System");
     }
     full_name() {
         return this.name + "-" + this.weight + (this.style === "Italic" ? "Italic" : "");

package/dist/Layout.d.ts

@@ -13,11 +13,14 @@ export declare class SectionLayout {
     constructor(inner: Stack | Row | Elem);
     copy(): SectionLayout;
     static constrMap(tag: string): Stack | Row | Elem;
+    static empty(): SectionLayout;
     static fromJson(json: any): SectionLayout;
+    toJson(): any;
     width(): Width;
     is_container(): boolean;
     is_ref(): boolean;
     type_(): "Stack" | "Row" | "Elem";
+    tag_(): "Stack" | "FlexRow" | "FrozenRow" | "Ref" | "Text";
     fonts(): Font[];
     with_margin(margin: Margin): SectionLayout;
     with_alignment(alignment: Alignment): SectionLayout;

package/dist/Layout.js

@@ -34,6 +34,9 @@ class SectionLayout {
             }
         }
     }
+    static empty() {
+        return new SectionLayout(Stack.default_());
+    }
     static fromJson(json) {
         const key = Object.keys(json)[0];
         switch (key) {
@@ -60,7 +63,37 @@ class SectionLayout {
                 return new SectionLayout(inner);
             }
         }
-        throw new Error("Invalid layout");
+        throw new Error(`Invalid layout ${key}`);
+    }
+    toJson() {
+        switch (this.type_()) {
+            case "Stack":
+            case "Row": {
+                const container = this.inner;
+                return {
+                    [this.tag_()]: {
+                        elements: container.elements.map(e => e.toJson()),
+                        margin: container.margin.toJson(),
+                        alignment: container.alignment,
+                        width: Width_1.Width.toJson(container.width),
+                    },
+                };
+            }
+            case "Elem": {
+                const elem = this.inner;
+                return {
+                    [this.tag_()]: {
+                        item: elem.item,
+                        margin: elem.margin.toJson(),
+                        alignment: elem.alignment,
+                        width: Width_1.Width.toJson(elem.width),
+                        text_width: Width_1.Width.toJson(elem.text_width),
+                        font: elem.font.toJson(),
+                        url: elem.url,
+                    },
+                };
+            }
+        }
     }
     width() {
         return this.inner.width;
@@ -74,6 +107,16 @@ class SectionLayout {
     type_() {
         return this.inner.tag;
     }
+    tag_() {
+        switch (this.type_()) {
+            case "Stack":
+                return "Stack";
+            case "Row":
+                return this.inner.is_frozen ? "FrozenRow" : "FlexRow";
+            case "Elem":
+                return this.is_ref() ? "Ref" : "Text";
+        }
+    }
     fonts() {
         switch (this.type_()) {
             case "Stack":
@@ -263,6 +306,9 @@ class SectionLayout {
                 if (elem.is_ref) {
                     throw new Error("Cannot compute textbox positions of uninstantiated layout");
                 }
+                if (elem.item === "") {
+                    return top_left.y;
+                }
                 const height = elem.font.get_height(font_dict);
                 const width = Width_1.Width.get_fixed_unchecked(elem.text_width);
                 switch (elem.alignment) {

package/dist/LayoutSchema.d.ts

@@ -1,9 +1,17 @@
 import { SectionLayout } from "./Layout";
 export declare class LayoutSchema {
     schema_name: string;
+    data_schema_name: string;
     header_layout_schema: SectionLayout;
     item_layout_schema: SectionLayout;
-    constructor(schema_name: string, header_layout_schema: SectionLayout, item_layout_schema: SectionLayout);
+    constructor(schema_name: string, data_schema_name: string, header_layout_schema: SectionLayout, item_layout_schema: SectionLayout);
+    static empty(schema_name: string, data_schema_name: string): LayoutSchema;
     static fromJson(json: any): LayoutSchema;
     fonts(): import("./Font").Font[];
+    toJson(): {
+        schema_name: string;
+        data_schema_name: string;
+        header_layout_schema: any;
+        item_layout_schema: any;
+    };
 }

package/dist/LayoutSchema.js

@@ -3,13 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayoutSchema = void 0;
 const Layout_1 = require("./Layout");
 class LayoutSchema {
-    constructor(schema_name, header_layout_schema, item_layout_schema) {
+    constructor(schema_name, data_schema_name, header_layout_schema, item_layout_schema) {
         this.schema_name = schema_name;
+        this.data_schema_name = data_schema_name;
         this.header_layout_schema = header_layout_schema;
         this.item_layout_schema = item_layout_schema;
     }
+    static empty(schema_name, data_schema_name) {
+        return new LayoutSchema(schema_name, data_schema_name, Layout_1.SectionLayout.empty(), Layout_1.SectionLayout.empty());
+    }
     static fromJson(json) {
-        return new LayoutSchema(json.schema_name, Layout_1.SectionLayout.fromJson(json.header_layout_schema), Layout_1.SectionLayout.fromJson(json.item_layout_schema));
+        console.error(json);
+        return new LayoutSchema(json.schema_name, json.data_schema_name, Layout_1.SectionLayout.fromJson(json.header_layout_schema), Layout_1.SectionLayout.fromJson(json.item_layout_schema));
     }
     fonts() {
         return [
@@ -17,5 +22,13 @@ class LayoutSchema {
             ...this.item_layout_schema.fonts(),
         ];
     }
+    toJson() {
+        return {
+            schema_name: this.schema_name,
+            data_schema_name: this.data_schema_name,
+            header_layout_schema: this.header_layout_schema.toJson(),
+            item_layout_schema: this.item_layout_schema.toJson(),
+        };
+    }
 }
 exports.LayoutSchema = LayoutSchema;

package/dist/LocalStorage.d.ts

@@ -4,20 +4,19 @@ import { Font } from "./Font";
 import { LayoutSchema } from "./LayoutSchema";
 import { Resume } from "./Resume";
 import { ResumeLayout } from "./ResumeLayout";
-import { Storage } from "./Storage";
-export declare class LocalStorage implements Storage {
+export declare class LocalStorage {
     initiate_storage(): Promise<void>;
-    list_resumes(): Promise<string[]>;
-    list_data_schemas(): Promise<string[]>;
-    list_layout_schemas(): Promise<string[]>;
-    list_resume_layouts(): Promise<string[]>;
-    load_resume(resume_name: string): Promise<Resume>;
-    load_data_schema(schema_name: string): Promise<DataSchema>;
-    load_layout_schema(schema_name: string): Promise<LayoutSchema>;
-    load_resume_layout(schema_name: string): Promise<ResumeLayout>;
-    save_resume(resume_name: string, resume_data: Resume): Promise<void>;
+    list_resumes(): string[];
+    list_data_schemas(): string[];
+    list_layout_schemas(): string[];
+    list_resume_layouts(): string[];
+    load_resume(resume_name: string): Resume;
+    load_data_schema(schema_name: string): DataSchema;
+    load_layout_schema(schema_name: string): LayoutSchema;
+    load_resume_layout(schema_name: string): ResumeLayout;
+    save_resume(resume_name: string, resume_data: Resume): void;
     save_data_schema(data_schema: DataSchema): Promise<void>;
-    save_layout_schema(layout_schema: LayoutSchema): Promise<void>;
-    save_resume_layout(resume_layout: ResumeLayout): Promise<void>;
+    save_layout_schema(layout_schema: LayoutSchema): void;
+    save_resume_layout(resume_layout: ResumeLayout): void;
     load_font(font: Font): Promise<Buffer>;
 }

package/dist/LocalStorage.js

@@ -5,12 +5,13 @@ const DataSchema_1 = require("./DataSchema");
 const LayoutSchema_1 = require("./LayoutSchema");
 const Resume_1 = require("./Resume");
 const ResumeLayout_1 = require("./ResumeLayout");
+// import { Storage } from "./Storage";
 class LocalStorage {
     async initiate_storage() {
         if (!localStorage.getItem("resumes")) {
-            fetch("https://d2bnplhbawocbk.cloudfront.net/data/resumes/resume2.json").then((response) => {
+            fetch("https://d2bnplhbawocbk.cloudfront.net/data/resumes/resume5.json").then((response) => {
                 response.json().then((resume) => {
-                    localStorage.setItem("resumes", JSON.stringify([{ name: "resume2", data: resume }]));
+                    localStorage.setItem("resumes", JSON.stringify([{ name: "resume5", data: resume }]));
                 });
             });
         }
@@ -22,7 +23,7 @@ class LocalStorage {
             });
         }
         if (!localStorage.getItem("section_layouts")) {
-            fetch("https://d2bnplhbawocbk.cloudfront.net/data/layout-schemas.json").then((response) => {
+            fetch("https://d2bnplhbawocbk.cloudfront.net/data/layout-schemas2.json").then((response) => {
                 response.json().then((section_layouts) => {
                     localStorage.setItem("section_layouts", JSON.stringify(section_layouts));
                 });
@@ -38,19 +39,19 @@ class LocalStorage {
     }
     list_resumes() {
         const resumes = JSON.parse(localStorage.getItem("resumes") || "[]").map((resume) => resume.name);
-        return Promise.resolve(resumes);
+        return resumes;
     }
     list_data_schemas() {
         const schemas = JSON.parse(localStorage.getItem("data_schemas") || "[]").map((schema) => schema.schema_name);
-        return Promise.resolve(schemas);
+        return schemas;
     }
     list_layout_schemas() {
         const schemas = JSON.parse(localStorage.getItem("section_layouts") || "[]").map((schema) => schema.schema_name);
-        return Promise.resolve(schemas);
+        return schemas;
     }
     list_resume_layouts() {
         const schemas = JSON.parse(localStorage.getItem("resume_layouts") || "[]").map((schema) => schema.schema_name);
-        return Promise.resolve(schemas);
+        return schemas;
     }
     load_resume(resume_name) {
         console.log(resume_name);
@@ -58,24 +59,22 @@ class LocalStorage {
         if (!resume) {
             throw new Error("Resume not found");
         }
-        return Promise.resolve(Resume_1.Resume.fromJson(resume.data));
+        return Resume_1.Resume.fromJson(resume.data);
     }
     load_data_schema(schema_name) {
+        console.error(schema_name);
         const schema = JSON.parse(localStorage.getItem("data_schemas") || "[]").find((schema) => schema.schema_name === schema_name);
         if (!schema) {
             throw new Error("Data schema not found");
         }
-        return Promise.resolve(DataSchema_1.DataSchema.fromJson(schema));
+        return DataSchema_1.DataSchema.fromJson(schema);
     }
     load_layout_schema(schema_name) {
         const schema = JSON.parse(localStorage.getItem("section_layouts") || "[]").find((schema) => schema.schema_name === schema_name);
-        console.info(schema);
-        console.info(schema_name);
-        console.info(localStorage.getItem("section_layouts"));
         if (!schema) {
             throw new Error("Layout schema not found");
         }
-        return Promise.resolve(LayoutSchema_1.LayoutSchema.fromJson(schema));
+        return LayoutSchema_1.LayoutSchema.fromJson(schema);
     }
     load_resume_layout(schema_name) {
         console.log(schema_name);
@@ -84,7 +83,7 @@ class LocalStorage {
             throw new Error("Resume layout not found");
         }
         console.info(schema);
-        return Promise.resolve(ResumeLayout_1.ResumeLayout.fromJson(schema));
+        return ResumeLayout_1.ResumeLayout.fromJson(schema);
     }
     save_resume(resume_name, resume_data) {
         const resumes = JSON.parse(localStorage.getItem("resumes") || "[]");
@@ -96,18 +95,29 @@ class LocalStorage {
             resume.data = resume_data.toJson();
         }
         localStorage.setItem("resumes", JSON.stringify(resumes));
-        return Promise.resolve();
     }
     save_data_schema(data_schema) {
         throw new Error("Method not implemented.");
     }
     save_layout_schema(layout_schema) {
-        throw new Error("Method not implemented.");
+        const schemasDirectMapped = JSON.parse(localStorage.getItem("section_layouts") || "[]");
+        const schemas = schemasDirectMapped.map((schema) => LayoutSchema_1.LayoutSchema.fromJson(schema));
+        const schema = schemas.find((schema) => schema.schema_name === layout_schema.schema_name);
+        if (!schema) {
+            schemas.push(layout_schema);
+        }
+        else {
+            schema.header_layout_schema = layout_schema.header_layout_schema;
+            schema.item_layout_schema = layout_schema.item_layout_schema;
+        }
+        console.error(schemas);
+        localStorage.setItem("section_layouts", JSON.stringify(schemas.map((schema) => schema.toJson())));
     }
     save_resume_layout(resume_layout) {
         throw new Error("Method not implemented.");
     }
     async load_font(font) {
+        console.error(font);
         const path = `fonts/${font.full_name()}.ttf`;
         if (!localStorage.getItem(path)) {
             const response = await fetch(`https://d2bnplhbawocbk.cloudfront.net/data/${path}`);

package/dist/Margin.d.ts

@@ -7,4 +7,10 @@ export declare class Margin {
     copy(): Margin;
     static default_(): Margin;
     static fromJson(json: any): Margin;
+    toJson(): {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
 }

package/dist/Margin.js

@@ -22,5 +22,13 @@ class Margin {
     static fromJson(json) {
         return new Margin(json.top, json.bottom, json.left, json.right);
     }
+    toJson() {
+        return {
+            top: this.top,
+            bottom: this.bottom,
+            left: this.left,
+            right: this.right,
+        };
+    }
 }
 exports.Margin = Margin;

package/dist/Resume.d.ts

@@ -17,7 +17,7 @@ export declare class ResumeSection {
     data_schema: string;
     layout_schema: string;
     data: Map<ItemName, ItemContent>;
-    items: Map<ItemName, ItemContent>[];
+    items: Item[];
     constructor();
     toJson(): unknown;
     static fromJson(json: unknown): ResumeSection;
@@ -38,6 +38,14 @@ export type ItemContent = {
         text: string;
     };
 };
+export type Item = {
+    id: string;
+    fields: Map<ItemName, ItemContent>;
+};
+export declare namespace Item {
+    function fromJson(json: unknown): Item;
+    function toJson(item: Item): unknown;
+}
 export declare namespace ItemContent {
     function fromJson(json: unknown): ItemContent;
     function None(): ItemContent;

package/dist/Resume.js

@@ -1,7 +1,7 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-namespace */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ItemContent = exports.ResumeSection = exports.Resume = void 0;
+exports.ItemContent = exports.Item = exports.ResumeSection = exports.Resume = void 0;
 class Resume {
     constructor(layout, sections) {
         this.layout = layout;
@@ -35,6 +35,8 @@ class Resume {
         }
     }
     data_schemas() {
+        console.error(this.sections);
+        console.error(this.sections.map(section => section.data_schema));
         return this.sections.map(section => section.data_schema);
     }
     layout_schemas() {
@@ -65,7 +67,7 @@ class ResumeSection {
             data_schema: this.data_schema,
             layout_schema: this.layout_schema,
             data: Object.fromEntries(this.data),
-            items: this.items.map(item => Object.fromEntries(item)),
+            items: this.items.map(item => Item.toJson(item)),
         };
     }
     static fromJson(json) {
@@ -86,13 +88,43 @@ class ResumeSection {
         // @ts-ignore
         section.data = new Map([...data].map(([key, value]) => [key, ItemContent.fromJson(value)]));
         section.items = json.items.map(item => {
-            const data = new Map(Object.entries(item));
-            return new Map([...data].map(([key, value]) => [key, ItemContent.fromJson(value)]));
+            const data = new Map(Object.entries(item.fields));
+            return {
+                id: item.id,
+                fields: new Map([...data].map(([key, value]) => [key, ItemContent.fromJson(value)]))
+            };
         });
         return section;
     }
 }
 exports.ResumeSection = ResumeSection;
+var Item;
+(function (Item) {
+    function fromJson(json) {
+        if (typeof json !== "object") {
+            throw new Error("Item must be an object");
+        }
+        if (json === null) {
+            throw new Error("Item must not be null");
+        }
+        if (!("id" in json) || !("fields" in json)) {
+            throw new Error("Item must have an id and fields");
+        }
+        const item = {
+            id: json.id,
+            fields: new Map(Object.entries(json.fields))
+        };
+        return item;
+    }
+    Item.fromJson = fromJson;
+    function toJson(item) {
+        return {
+            id: item.id,
+            fields: Object.fromEntries(item.fields)
+        };
+    }
+    Item.toJson = toJson;
+})(Item || (exports.Item = Item = {}));
 var ItemContent;
 (function (ItemContent) {
     // @ts-ignore
@@ -106,10 +138,11 @@ var ItemContent;
         if (Array.isArray(json)) {
             return { tag: "List", value: json.map(fromJson) };
         }
+        if (typeof json === "object" && ("tag" in json) && json.tag === "None") {
+            return { tag: "None" };
+        }
         if (typeof json === "object" && ("tag" in json) && ("value" in json)) {
             switch (json.tag) {
-                case "None":
-                    return { tag: "None" };
                 case "String":
                     return { tag: "String", value: json.value };
                 case "List":
@@ -121,7 +154,7 @@ var ItemContent;
         else if (typeof json === "object" && ("url" in json) && ("text" in json)) {
             return { tag: "Url", value: { url: json.url, text: json.text } };
         }
-        throw new Error("ItemContent must be a string, an array, or an object");
+        throw new Error(`Invalid ItemContent(${JSON.stringify(json)}): ItemContent must be a string, an array, or an object`);
     }
     ItemContent.fromJson = fromJson;
     function None() {

package/dist/Width.d.ts

@@ -20,4 +20,5 @@ export declare namespace Width {
     function get_fixed_unchecked(self: Width): number;
     function scale(self: Width, scale: number): Width;
     function fromJson(json: any): Width;
+    function toJson(self: Width): any;
 }

package/dist/Width.js

@@ -76,4 +76,15 @@ var Width;
         }
     }
     Width.fromJson = fromJson;
+    function toJson(self) {
+        switch (self.tag) {
+            case "Percent":
+                return self.value + "%";
+            case "Absolute":
+                return self.value + "px";
+            case "Fill":
+                return "Fill";
+        }
+    }
+    Width.toJson = toJson;
 })(Width || (exports.Width = Width = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cvdl-ts",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "description": "Typescript Implementation of CVDL Compiler",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",