cvdl-ts 1.0.10 → 1.0.12

package/dist/Alignment.d.ts

@@ -1,4 +1,4 @@
-export type Alignment = "Left" | "Center" | "Right" | "Justified";
-export declare namespace Alignment {
-    function default_(): Alignment;
-}
+export type t = "Left" | "Center" | "Right" | "Justified";
+type Alignment = t;
+export declare function default_(): Alignment;
+export {};

package/dist/Alignment.js

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

package/dist/AnyLayout.d.ts

@@ -1,11 +1,10 @@
-import { Box } from "./Box";
 import { DataSchema } from "./DataSchema";
-import { Elem } from "./Layout";
 import { LayoutSchema } from "./LayoutSchema";
-import { LocalStorage } from "./LocalStorage";
+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,26 +20,18 @@ 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[];
     data_schemas: DataSchema[];
     resume_layout: ResumeLayout;
-    storage: LocalStorage;
+    storage: Storage;
     fontDict?: FontDict;
 };
 export declare class FontDict {
     fonts: Map<string, fontkit.Font>;
     constructor();
-    load_fonts_from_schema(schema: LayoutSchema, storage: LocalStorage): Promise<void>;
+    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[][]]>;
+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);
@@ -83,7 +62,10 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
     const column_width = resume_layout.column_type.tag === "SingleColumn"
         ? 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);
@@ -103,25 +85,18 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         }
         start_time = Date.now();
         // 3. Render the header
-        const result = layout_schema
-            .header_layout_schema
-            .copy()
-            .instantiate(section.data)
-            .normalize(column_width, font_dict)
-            .compute_boxes(font_dict);
+        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");
+        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");
+            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);
@@ -135,39 +110,13 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
             const _data_schema = data_schemas
                 .find((s) => s.schema_name == section.data_schema);
             // 3. Render the item
-            const result = layout_schema
-                .item_layout_schema
-                .copy()
-                .instantiate(item.fields)
-                .normalize(column_width, font_dict)
-                .compute_boxes(font_dict);
-            result.path = {
-                tag: 'item',
-                section: section.section_name,
-                item: index
-            };
-            boxes.push(result);
+            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields), column_width, font_dict), font_dict);
+            layouts.push(layout);
         }
         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];
+    return [font_dict, layouts];
 }
 exports.render = render;

package/dist/Elem.d.ts

@@ -0,0 +1,58 @@
+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";
+export type t = {
+    tag: "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;
+};
+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 copy(e: Elem): {
+    tag: "Elem";
+    item: string;
+    url: string;
+    is_ref: boolean;
+    is_fill: 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 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;
+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 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 {};

package/dist/Elem.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, 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;
+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) {
+    return {
+        tag: "Elem",
+        item,
+        url,
+        is_ref,
+        is_fill,
+        text_width,
+        font,
+        margin,
+        alignment,
+        width,
+        background_color,
+    };
+}
+exports.elem = elem;
+function copy(e) {
+    return { ...e };
+}
+exports.copy = copy;
+function default_() {
+    return {
+        tag: "Elem",
+        item: "",
+        url: null,
+        is_ref: false,
+        is_fill: false,
+        text_width: _1.Width.default_(),
+        font: Font.default_(),
+        margin: _1.Margin.default_(),
+        alignment: _1.Alignment.default_(),
+        width: _1.Width.default_(),
+        background_color: "Transparent",
+    };
+}
+exports.default_ = default_;
+function with_(e, w) {
+    return { ...e, ...w };
+}
+exports.with_ = with_;
+function from(w) {
+    return { ...default_(), ...w };
+}
+exports.from = from;
+function withItem(e, item) {
+    return { ...e, item };
+}
+exports.withItem = withItem;
+function withUrl(e, url) {
+    return { ...e, url };
+}
+exports.withUrl = withUrl;
+function withIsRef(e, is_ref) {
+    return { ...e, is_ref };
+}
+exports.withIsRef = withIsRef;
+function asRef(e) {
+    return withIsRef(e, true);
+}
+exports.asRef = asRef;
+function withIsFill(e, is_fill) {
+    return { ...e, is_fill };
+}
+exports.withIsFill = withIsFill;
+function withTextWidth(e, text_width) {
+    return { ...e, text_width };
+}
+exports.withTextWidth = withTextWidth;
+function withFont(e, font) {
+    return { ...e, font };
+}
+exports.withFont = withFont;
+function withMargin(e, margin) {
+    return { ...e, margin };
+}
+exports.withMargin = withMargin;
+function withAlignment(e, alignment) {
+    return { ...e, alignment };
+}
+exports.withAlignment = withAlignment;
+function withWidth(e, width) {
+    return { ...e, width };
+}
+exports.withWidth = withWidth;
+function withBackgroundColor(e, background_color) {
+    return { ...e, background_color };
+}
+exports.withBackgroundColor = withBackgroundColor;
+function scaleWidth(e, scale) {
+    return withWidth(e, _1.Width.scale(e.width, scale));
+}
+exports.scaleWidth = scaleWidth;
+function fillFonts(e, fonts) {
+    const text_width_with_font = Font.get_width(e.font, e.item, fonts);
+    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));
+    }
+    else {
+        return withTextWidth(e, _1.Width.absolute(text_width_with_font));
+    }
+}
+exports.fillFonts = fillFonts;
+function justifiedLines(e, lines, font_dict) {
+    const rowLines = [];
+    for (const line of lines.slice(0, -1)) {
+        const words = line.item.split(/\s+/);
+        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));
+        });
+        rowLines.push(Row_1.row);
+    }
+    rowLines.push((0, Row_1.row)([withAlignment(lines[lines.length - 1], "Left")], lines[0].margin, "Left", lines[0].width, false, false));
+    return rowLines;
+}
+exports.justifiedLines = justifiedLines;
+function break_lines(e, font_dict) {
+    if (_1.Width.get_fixed_unchecked(e.text_width) <= _1.Width.get_fixed_unchecked(e.width)) {
+        return [e];
+    }
+    const lines = [];
+    // todo: I'm sure this implementation is pretty buggy. Note to future me, fix
+    // this.
+    const words = e.item.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;
+    let width = widths[0];
+    const max_width = _1.Width.get_fixed_unchecked(e.width);
+    for (let i = 1; i < words.length; i++) {
+        const candidate_width = width + space_width + widths[i];
+        if (candidate_width > max_width) {
+            const line = words.slice(start, i).join(" ");
+            const line_width = Font.get_width(e.font, line, font_dict);
+            lines.push(withTextWidth(withItem(e, line), _1.Width.absolute(line_width)));
+            start = i;
+            width = widths[i];
+        }
+        else {
+            width += space_width + widths[i];
+        }
+    }
+    const line = words.slice(start).join(" ");
+    const line_width = Font.get_width(e.font, line, font_dict);
+    lines.push(withTextWidth(withItem(e, line), _1.Width.absolute(line_width)));
+    if (e.alignment === "Justified") {
+        return justifiedLines(e, lines, font_dict);
+    }
+    return lines;
+}
+exports.break_lines = break_lines;
+function boundWidth(e, width) {
+    if (!_1.Width.is_fill(e.width)) {
+        return withIsFill(withWidth(e, _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), width))), false);
+    }
+    else {
+        return withIsFill(withWidth(e, _1.Width.absolute(width)), true);
+    }
+}
+exports.boundWidth = boundWidth;
+function instantiate(e, section) {
+    if (!e.is_ref) {
+        return e;
+    }
+    const text = section.get(e.item);
+    if (text === undefined) {
+        return withIsRef(withItem(e, ""), false);
+    }
+    else {
+        if (text.tag === "Url") {
+            return withIsRef(withUrl(withItem(e, text.value.text), text.value.url), false);
+        }
+        else {
+            return withIsRef(withItem(e, Resume_1.ItemContent.toString(text)), false);
+        }
+    }
+}
+exports.instantiate = instantiate;

package/dist/FileStorage.d.ts

@@ -4,11 +4,11 @@ import { DataSchema } from "./DataSchema";
 import { LayoutSchema } from "./LayoutSchema";
 import { ResumeLayout } from "./ResumeLayout";
 import { Storage } from "./Storage";
-import { Font } from "./Font";
+import * as Font from "./Font";
 export declare class FileStorage implements Storage {
     dir: string;
     constructor(dir: string);
-    load_font(font: Font): Promise<Buffer>;
+    load_font(font: Font.t): Promise<Buffer>;
     initiate_storage(): Promise<void>;
     list_resumes(): Promise<string[]>;
     list_data_schemas(): Promise<string[]>;

package/dist/FileStorage.js

@@ -1,5 +1,28 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,13 +53,14 @@ const Resume_1 = require("./Resume");
 const DataSchema_1 = require("./DataSchema");
 const LayoutSchema_1 = require("./LayoutSchema");
 const ResumeLayout_1 = require("./ResumeLayout");
+const Font = __importStar(require("./Font"));
 class FileStorage {
     constructor(dir) {
         this.dir = "";
         this.dir = dir;
     }
     load_font(font) {
-        throw new Error("Method not implemented.");
+        return Promise.resolve(fs_1.default.readFileSync(this.dir + Font.full_name(font) + ".ttf"));
     }
     initiate_storage() {
         // Create data_dir/resumes if it does not exist

package/dist/Font.d.ts

@@ -1,18 +1,19 @@
 import { FontDict } from "./AnyLayout";
-export declare class Font {
+export type t = {
     name: string;
     size: number;
     weight: FontWeight;
     style: FontStyle;
     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;
-    get_height(fonts: FontDict): number;
-}
+};
+type Font = t;
+export declare function font(name: string, size: number, weight: FontWeight, style: FontStyle, source: FontSource): Font;
+export declare function fromJson(json: unknown): Font;
+export declare function default_(): Font;
+export declare function full_name(f: Font): string;
+export declare function get_width(f: Font, text: string, fonts: FontDict): number;
+export declare function get_height(f: Font, fonts: FontDict): number;
 export type FontSource = "Local" | "System" | "Remote";
 export type FontWeight = "Light" | "Medium" | "Bold";
 export type FontStyle = "Normal" | "Italic";
+export {};

package/dist/Font.js

@@ -1,47 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Font = void 0;
-class Font {
-    constructor(name, size, weight, style, source) {
-        this.name = name;
-        this.size = size;
-        this.weight = weight;
-        this.style = style;
-        this.source = source;
-    }
-    static fromJson(json) {
-        if (typeof json !== "object" || json === null) {
-            return Font.default_();
-        }
-        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("Exo", 12, "Medium", "Normal", "System");
-    }
-    full_name() {
-        return this.name + "-" + this.weight + (this.style === "Italic" ? "Italic" : "");
-    }
-    get_width(text, fonts) {
-        const font = fonts.get_font(this.full_name());
-        return (font.layout(text).glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) / font.unitsPerEm) * this.size;
-    }
-    get_height(fonts) {
-        const font = fonts.get_font(this.full_name());
-        return (font.bbox.height / font.unitsPerEm) * this.size;
-    }
+exports.get_height = exports.get_width = exports.full_name = exports.default_ = exports.fromJson = exports.font = void 0;
+function font(name, size, weight, style, source) {
+    return {
+        name,
+        size,
+        weight,
+        style,
+        source,
+    };
 }
-exports.Font = Font;
+exports.font = font;
+function fromJson(json) {
+    return {
+        ...default_(),
+        name: json["name"],
+        size: json["size"],
+        weight: json["weight"],
+        style: json["style"],
+        source: json["source"],
+    };
+}
+exports.fromJson = fromJson;
+function default_() {
+    return {
+        name: "Exo",
+        size: 12,
+        weight: "Medium",
+        style: "Normal",
+        source: "System",
+    };
+}
+exports.default_ = default_;
+function full_name(f) {
+    return f.name + "-" + f.weight + (f.style === "Italic" ? "Italic" : "");
+}
+exports.full_name = full_name;
+function get_width(f, text, fonts) {
+    const font = fonts.get_font(full_name(f));
+    return (font.layout(text).glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) / font.unitsPerEm) * f.size;
+}
+exports.get_width = get_width;
+function get_height(f, fonts) {
+    const font = fonts.get_font(full_name(f));
+    return (font.bbox.height / font.unitsPerEm) * f.size;
+}
+exports.get_height = get_height;