@nmmty/lazycanvas 0.4.0 → 0.5.1

package/dist/structures/components/TextLayer.js

@@ -2,21 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextLayer = void 0;
 const BaseLayer_1 = require("./BaseLayer");
-const enum_1 = require("../../types/enum");
+const types_1 = require("../../types");
 const LazyUtil_1 = require("../../utils/LazyUtil");
-const Gradient_1 = require("../helpers/Gradient");
 const utils_1 = require("../../utils/utils");
-const Pattern_1 = require("../helpers/Pattern");
+/**
+ * Class representing a Text Layer, extending the BaseLayer class.
+ */
 class TextLayer extends BaseLayer_1.BaseLayer {
+    /**
+     * The properties of the Text Layer.
+     */
     props;
-    constructor(props) {
-        super(enum_1.LayerType.Text, props || {});
+    /**
+     * Constructs a new TextLayer instance.
+     * @param props {ITextLayerProps} - The properties of the Text Layer.
+     * @param misc {IBaseLayerMisc} - Miscellaneous options for the layer.
+     */
+    constructor(props, misc) {
+        super(types_1.LayerType.Text, props || {}, misc);
         this.props = props ? props : {};
-        this.props.align = enum_1.TextAlign.Left;
+        this.props.align = types_1.TextAlign.Left;
         this.props.font = {
             family: 'Geist',
             size: 16,
-            weight: enum_1.FontWeight.Regular,
+            weight: types_1.FontWeight.Regular,
         };
         this.props.fillStyle = '#ffffff';
         this.props.filled = true;
@@ -28,23 +37,26 @@ class TextLayer extends BaseLayer_1.BaseLayer {
             width: 'vw',
             height: 0,
         };
-        this.props.centring = enum_1.Centring.Center;
+        this.props.centring = types_1.Centring.Center;
         this.props.wordSpacing = 0;
         this.props.letterSpacing = 0;
     }
     /**
-     * @description Sets the text of the text layer.
-     * @param text {string} - The `text` of the text layer.
+     * Sets the text of the text layer.
+     * @param text {string} - The text content of the layer.
+     * @returns {this} The current instance for chaining.
      */
     setText(text) {
         this.props.text = text;
         return this;
     }
     /**
-     * @description Set the font of the text layer. You can use `Geist` and `GeistMono`, or you can upload your own font from file/base64 buffer.
-     * @param familyOrConfig {string | { font: string; size: number; weight: AnyWeight }} - The `family` of the font. If you want to use FontsList, you can use the object config.
-     * @param size {number} - The `size` of the font.
-     * @param weight {AnyWeight} - The `weight` of the font.
+     * Sets the font of the text layer.
+     * @param familyOrConfig {string | { family: string; size: number; weight: AnyWeight }} - The font family or configuration object.
+     * @param size {number} - The font size (required if `familyOrConfig` is a string).
+     * @param weight {AnyWeight} - The font weight (required if `familyOrConfig` is a string).
+     * @returns {this} The current instance for chaining.
+     * @throws {LazyError} If size or weight is not provided when `familyOrConfig` is a string.
      */
     setFont(familyOrConfig, size, weight) {
         if (typeof familyOrConfig === "string") {
@@ -68,11 +80,12 @@ class TextLayer extends BaseLayer_1.BaseLayer {
         return this;
     }
     /**
-     * @description Set the multiline of the text layer. You can use `numbers`, `percentages`, `px`, `vw`, `vh`, `vmin`, `vmax`.
-     * @param enabled {boolean} - Whether the text is multiline.
-     * @param width {ScaleType} - width of "window" the multiline text. Can be used in one line text for text max width.
-     * @param height {ScaleType} - height of "window" the multiline text.
-     * @param spacing {number} - The space between the lines.
+     * Configures the multiline properties of the text layer.
+     * @param enabled {boolean} - Whether multiline is enabled.
+     * @param width {ScaleType} - The width of the multiline text area.
+     * @param height {ScaleType} - The height of the multiline text area.
+     * @param spacing {number} - The spacing between lines (optional).
+     * @returns {this} The current instance for chaining.
      */
     setMultiline(enabled, width, height, spacing) {
         this.props.multiline = {
@@ -86,57 +99,55 @@ class TextLayer extends BaseLayer_1.BaseLayer {
         return this;
     }
     /**
-     * @description Sets the color of the layer. You can use `hex`, `rgb`, `rgba`, `hsl`, `hsla`, and `Gradient`color.
-     * @param color {string} - The `color` of the layer.
+     * Sets the color of the text layer.
+     * @param color {ColorType} - The color of the text.
+     * @returns {this} The current instance for chaining.
+     * @throws {LazyError} If the color is not provided or invalid.
      */
     setColor(color) {
         if (!color)
             throw new LazyUtil_1.LazyError('The color of the layer must be provided');
         if (!(0, utils_1.isColor)(color))
             throw new LazyUtil_1.LazyError('The color of the layer must be a valid color');
-        let fill = (0, utils_1.parseColor)(color);
-        if (fill instanceof Gradient_1.Gradient || fill instanceof Pattern_1.Pattern) {
-            this.props.fillStyle = fill;
-        }
-        else {
-            let arr = fill.split(':');
-            this.props.fillStyle = arr[0];
-            this.props.opacity = parseFloat(arr[1]) || 1;
-        }
+        this.props.fillStyle = color;
         return this;
     }
     /**
-     * @description Set the align of the text layer.
-     * @param align {AnyTextAlign} - The `align` of the text layer.
+     * Sets the alignment of the text layer.
+     * @param align {AnyTextAlign} - The alignment of the text.
+     * @returns {this} The current instance for chaining.
      */
     setAlign(align) {
         this.props.align = align;
         return this;
     }
     /**
-     * @description Set the baseline of the text layer.
-     * @param baseline {AnyTextBaseline} - The `baseline` of the text layer.
+     * Sets the baseline of the text layer.
+     * @param baseline {AnyTextBaseline} - The baseline of the text.
+     * @returns {this} The current instance for chaining.
      */
     setBaseline(baseline) {
         this.props.baseline = baseline;
         return this;
     }
     /**
-     * @description Set the direction of the text layer.
-     * @param direction {AnyTextDirection} - The `direction` of the text layer.
+     * Sets the direction of the text layer.
+     * @param direction {AnyTextDirection} - The direction of the text.
+     * @returns {this} The current instance for chaining.
      */
     setDirection(direction) {
         this.props.direction = direction;
         return this;
     }
     /**
-     * @description Set the stroke of the layer.
-     * @param width {number} - The `width` of the stroke.
-     * @param cap {string} - The `cap` of the stroke.
-     * @param join {string} - The `join` of the stroke.
-     * @param dash {number[]} - The `dash` of the stroke.
-     * @param dashOffset {number} - The `dashOffset` of the stroke.
-     * @param miterLimit {number} - The `miterLimit` of the stroke.
+     * Configures the stroke properties of the text layer.
+     * @param width {number} - The width of the stroke.
+     * @param cap {string} - The cap style of the stroke (optional).
+     * @param join {string} - The join style of the stroke (optional).
+     * @param dash {number[]} - The dash pattern of the stroke (optional).
+     * @param dashOffset {number} - The dash offset of the stroke (optional).
+     * @param miterLimit {number} - The miter limit of the stroke (optional).
+     * @returns {this} The current instance for chaining.
      */
     setStroke(width, cap, join, dash, dashOffset, miterLimit) {
         this.props.stroke = {
@@ -150,29 +161,38 @@ class TextLayer extends BaseLayer_1.BaseLayer {
         return this;
     }
     /**
-     * @description Sets the fills of the layer. If `true` the layer will be filled, if `false` the layer will be stroked.
-     * @param filled {boolean} - The `filled` of the layer.
+     * Sets whether the text layer should be filled or stroked.
+     * @param filled {boolean} - If true, the layer will be filled; otherwise, it will be stroked.
+     * @returns {this} The current instance for chaining.
      */
     setFilled(filled) {
         this.props.filled = filled;
         return this;
     }
     /**
-     * @description Sets the spacing between the words.
-     * @param wordSpacing {number} - The `wordSpacing` of the text layer.
+     * Sets the spacing between words in the text layer.
+     * @param wordSpacing {number} - The spacing between words.
+     * @returns {this} The current instance for chaining.
      */
     setWordSpacing(wordSpacing) {
         this.props.wordSpacing = wordSpacing;
         return this;
     }
     /**
-     * @description Sets the letter spacing.
-     * @param letterSpacing {number} - The `letterSpacing` of the text layer.
+     * Sets the spacing between letters in the text layer.
+     * @param letterSpacing {number} - The spacing between letters.
+     * @returns {this} The current instance for chaining.
      */
     setLetterSpacing(letterSpacing) {
         this.props.letterSpacing = letterSpacing;
         return this;
     }
+    /**
+     * Measures the dimensions of the text.
+     * @param ctx {SKRSContext2D} - The canvas rendering context.
+     * @param canvas {Canvas | SvgCanvas} - The canvas instance.
+     * @returns {Object} The width and height of the text.
+     */
     measureText(ctx, canvas) {
         const w = (0, utils_1.parseToNormal)(this.props.size?.width, ctx, canvas);
         const h = (0, utils_1.parseToNormal)(this.props.size?.height, ctx, canvas, { width: w, height: 0 }, { vertical: true });
@@ -185,6 +205,13 @@ class TextLayer extends BaseLayer_1.BaseLayer {
             return { width: data.width, height: this.props.font.size };
         }
     }
+    /**
+     * Draws the text layer on the canvas.
+     * @param ctx {SKRSContext2D} - The canvas rendering context.
+     * @param canvas {Canvas | SvgCanvas} - The canvas instance.
+     * @param manager {LayersManager} - The layers manager.
+     * @param debug {boolean} - Whether to enable debug logging.
+     */
     async draw(ctx, canvas, manager, debug) {
         const parcer = (0, utils_1.parser)(ctx, canvas, manager);
         const { x, y, w } = parcer.parseBatch({
@@ -234,17 +261,27 @@ class TextLayer extends BaseLayer_1.BaseLayer {
                     break;
             }
             for (let line of lines) {
-                this.drawText(this.props, ctx, await (0, utils_1.parseFillStyle)(ctx, this.props.fillStyle), line.text, line.x, line.y, w, h);
+                this.drawText(this.props, ctx, await (0, utils_1.parseFillStyle)(ctx, this.props.fillStyle), line.text, line.x, line.y, w);
             }
         }
         else {
             ctx.font = `${this.props.font.weight} ${this.props.font.size}px ${this.props.font.family}`;
-            this.drawText(this.props, ctx, await (0, utils_1.parseFillStyle)(ctx, this.props.fillStyle), this.props.text, x, y, w, h);
+            this.drawText(this.props, ctx, await (0, utils_1.parseFillStyle)(ctx, this.props.fillStyle), this.props.text, x, y, w);
         }
         ctx.closePath();
         ctx.restore();
     }
-    drawText(props, ctx, fillStyle, text, x, y, w, h) {
+    /**
+     * Draws the text on the canvas.
+     * @param props {ITextLayerProps} - The properties of the text layer.
+     * @param ctx {SKRSContext2D} - The canvas rendering context.
+     * @param fillStyle {string | CanvasGradient | CanvasPattern} - The fill style for the text.
+     * @param text {string} - The text content.
+     * @param x {number} - The x-coordinate of the text.
+     * @param y {number} - The y-coordinate of the text.
+     * @param w {number} - The width of the text area.
+     */
+    drawText(props, ctx, fillStyle, text, x, y, w) {
         if (props.filled) {
             ctx.fillStyle = fillStyle;
             ctx.fillText(text, x, y, w);
@@ -261,12 +298,18 @@ class TextLayer extends BaseLayer_1.BaseLayer {
         }
     }
     /**
-     * @returns {ITextLayer}
+     * Converts the Text Layer to a JSON representation.
+     * @returns {ITextLayer} The JSON representation of the Text Layer.
      */
     toJSON() {
         let data = super.toJSON();
-        data.props = this.props;
-        return { ...data };
+        let copy = { ...this.props };
+        for (const key of ['x', 'y', 'size.width', 'size.height', 'fillStyle']) {
+            if (copy[key] && typeof copy[key] === 'object' && 'toJSON' in copy[key]) {
+                copy[key] = copy[key].toJSON();
+            }
+        }
+        return { ...data, props: copy };
     }
 }
 exports.TextLayer = TextLayer;

package/dist/structures/components/index.d.ts

@@ -0,0 +1,10 @@
+export * from './BaseLayer';
+export * from './BezierLayer';
+export * from './ClearLayer';
+export * from './ImageLayer';
+export * from './TextLayer';
+export * from './MorphLayer';
+export * from './Group';
+export * from './LineLayer';
+export * from './QuadraticLayer';
+export * from './Path2DLayer';

package/dist/structures/components/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BaseLayer"), exports);
+__exportStar(require("./BezierLayer"), exports);
+__exportStar(require("./ClearLayer"), exports);
+__exportStar(require("./ImageLayer"), exports);
+__exportStar(require("./TextLayer"), exports);
+__exportStar(require("./MorphLayer"), exports);
+__exportStar(require("./Group"), exports);
+__exportStar(require("./LineLayer"), exports);
+__exportStar(require("./QuadraticLayer"), exports);
+__exportStar(require("./Path2DLayer"), exports);

package/dist/structures/helpers/Exporter.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IOLazyCanvas, LazyCanvas } from "../LazyCanvas";
+import { AnyExport } from "../../types";
+import { Canvas, SKRSContext2D, SvgCanvas } from "@napi-rs/canvas";
+/**
+ * Class responsible for exporting a LazyCanvas instance to various formats.
+ */
+export declare class Exporter {
+    /**
+     * The LazyCanvas instance to be exported.
+     */
+    canvas: LazyCanvas;
+    /**
+     * Constructs a new Exporter instance.
+     * @param canvas {LazyCanvas} - The LazyCanvas instance to be exported.
+     */
+    constructor(canvas: LazyCanvas);
+    /**
+     * Saves a file to the filesystem.
+     * @param buffer {any} - The data to be saved.
+     * @param extension {Extensions} - The file extension.
+     * @param name {string} - The name of the file (optional).
+     * @throws {LazyError} If the buffer or extension is not provided.
+     */
+    private saveFile;
+    /**
+     * Exports all layers from the LayersManager as an array of JSON objects.
+     * @param manager {LayersManager} - The LayersManager instance.
+     * @returns {any[]} An array of JSON representations of the layers.
+     */
+    private exportLayers;
+    /**
+     * Exports the canvas to the specified format.
+     * @param exportType {AnyExport} - The type of export (e.g., "png", "json").
+     * @param opts {Object} - Optional settings.
+     * @param opts.name {string} - The name of the file (optional).
+     * @param opts.saveAsFile {boolean} - Whether to save the export as a file (optional).
+     * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The exported data.
+     * @throws {LazyError} If the export type is not supported.
+     */
+    export(exportType: AnyExport, opts?: {
+        name?: string;
+        saveAsFile?: boolean;
+    }): Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>;
+    /**
+     * Synchronously exports the canvas to the specified format.
+     * @param exportType {AnyExport} - The type of export (e.g., "json").
+     * @returns {IOLazyCanvas | void} The exported data or void if the export type is unsupported.
+     */
+    syncExport(exportType: AnyExport): IOLazyCanvas | void;
+}

package/dist/structures/helpers/Exporter.js

@@ -0,0 +1,168 @@
+"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.Exporter = void 0;
+const types_1 = require("../../types");
+const LazyUtil_1 = require("../../utils/LazyUtil");
+const fs = __importStar(require("fs"));
+const utils_1 = require("../../utils/utils");
+const _yaml = __importStar(require("js-yaml"));
+/**
+ * Class responsible for exporting a LazyCanvas instance to various formats.
+ */
+class Exporter {
+    /**
+     * The LazyCanvas instance to be exported.
+     */
+    canvas;
+    /**
+     * Constructs a new Exporter instance.
+     * @param canvas {LazyCanvas} - The LazyCanvas instance to be exported.
+     */
+    constructor(canvas) {
+        this.canvas = canvas;
+    }
+    /**
+     * Saves a file to the filesystem.
+     * @param buffer {any} - The data to be saved.
+     * @param extension {Extensions} - The file extension.
+     * @param name {string} - The name of the file (optional).
+     * @throws {LazyError} If the buffer or extension is not provided.
+     */
+    async saveFile(buffer, extension, name) {
+        if (!buffer)
+            throw new LazyUtil_1.LazyError('Buffer must be provided');
+        if (!extension)
+            throw new LazyUtil_1.LazyError('Extension must be provided');
+        fs.writeFileSync(`${name === undefined ? (0, utils_1.generateRandomName)() : name}.${extension}`, buffer);
+    }
+    /**
+     * Exports all layers from the LayersManager as an array of JSON objects.
+     * @param manager {LayersManager} - The LayersManager instance.
+     * @returns {any[]} An array of JSON representations of the layers.
+     */
+    exportLayers(manager) {
+        let arr = [];
+        for (const layer of Array.from(manager.map.values())) {
+            arr.push(layer.toJSON());
+        }
+        return arr;
+    }
+    /**
+     * Exports the canvas to the specified format.
+     * @param exportType {AnyExport} - The type of export (e.g., "png", "json").
+     * @param opts {Object} - Optional settings.
+     * @param opts.name {string} - The name of the file (optional).
+     * @param opts.saveAsFile {boolean} - Whether to save the export as a file (optional).
+     * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The exported data.
+     * @throws {LazyError} If the export type is not supported.
+     */
+    async export(exportType, opts) {
+        switch (exportType) {
+            case types_1.Export.CTX:
+            case "ctx":
+                return await this.canvas.manager.render.render(exportType);
+            case types_1.Export.SVG:
+            case "svg":
+                const svg = await this.canvas.manager.render.render('svg');
+                if (opts?.saveAsFile) {
+                    await this.saveFile(svg, 'svg', opts.name);
+                }
+                return svg;
+            case types_1.Export.BUFFER:
+            case "buffer":
+                const buffer = await this.canvas.manager.render.render('buffer');
+                if (opts?.saveAsFile) {
+                    await this.saveFile(buffer, 'png', opts.name);
+                }
+                return buffer;
+            case types_1.Export.GIF:
+            case "gif":
+                const gif = await this.canvas.manager.render.render('buffer');
+                if (opts?.saveAsFile) {
+                    await this.saveFile(gif, 'gif', opts.name);
+                }
+                return gif;
+            case types_1.Export.WEBP:
+            case "webp":
+                const webp = await this.canvas.manager.render.render('buffer');
+                if (opts?.saveAsFile) {
+                    await this.saveFile(webp, 'webp', opts.name);
+                }
+                return webp;
+            case types_1.Export.JPEG:
+            case "jpeg":
+                const jpeg = await this.canvas.manager.render.render('buffer');
+                await this.saveFile(jpeg, 'jpeg', opts?.name);
+                return jpeg;
+            case types_1.Export.JPG:
+            case "jpg":
+                const jpg = await this.canvas.manager.render.render('buffer');
+                await this.saveFile(jpg, 'jpg', opts?.name);
+                return jpg;
+            case types_1.Export.PNG:
+            case "png":
+                const png = await this.canvas.manager.render.render('buffer');
+                await this.saveFile(png, 'png', opts?.name);
+                return png;
+            case types_1.Export.JSON:
+            case "json":
+                const json = this.syncExport(exportType);
+                if (opts?.saveAsFile) {
+                    await this.saveFile(JSON.stringify(json), 'json', opts.name);
+                }
+                return JSON.stringify(json);
+            case types_1.Export.CANVAS:
+            case "canvas":
+                return await this.canvas.manager.render.render(exportType);
+            case types_1.Export.YAML:
+            case "yaml":
+                const yaml = _yaml.dump(this.syncExport(types_1.Export.JSON));
+                if (opts?.saveAsFile) {
+                    await this.saveFile(yaml, 'yaml', opts.name);
+                }
+                return yaml;
+            default:
+                throw new LazyUtil_1.LazyError(`Export type ${exportType} is not supported`);
+        }
+    }
+    /**
+     * Synchronously exports the canvas to the specified format.
+     * @param exportType {AnyExport} - The type of export (e.g., "json").
+     * @returns {IOLazyCanvas | void} The exported data or void if the export type is unsupported.
+     */
+    syncExport(exportType) {
+        switch (exportType) {
+            case types_1.Export.JSON:
+            case "json":
+                return {
+                    options: this.canvas.options,
+                    animation: this.canvas.manager.animation.options,
+                    layers: this.exportLayers(this.canvas.manager.layers)
+                };
+        }
+    }
+}
+exports.Exporter = Exporter;

package/dist/structures/helpers/Font.d.ts

@@ -1,35 +1,89 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { AnyWeight } from "../../types";
-import { IFont } from "../../types";
+/**
+ * Interface representing a font.
+ */
+export interface IFont {
+    /**
+     * The font family.
+     */
+    family: string;
+    /**
+     * The weight of the font.
+     */
+    weight: AnyWeight;
+    /**
+     * The file path of the font (optional).
+     */
+    path?: string;
+    /**
+     * The base64 representation of the font (optional).
+     */
+    base64?: Buffer;
+}
+/**
+ * Interface representing a collection of fonts.
+ * Each font family maps to a record of font weights and their corresponding buffers.
+ */
+export interface IFonts {
+    [family: string]: Record<number, Buffer>;
+}
+/**
+ * Class representing a font with properties such as family, weight, path, and base64.
+ */
 export declare class Font implements IFont {
+    /**
+     * The font family.
+     */
     family: string;
+    /**
+     * The weight of the font.
+     */
     weight: AnyWeight;
+    /**
+     * The file path of the font (optional).
+     */
     path?: string;
+    /**
+     * The base64 representation of the font (optional).
+     */
     base64?: Buffer;
+    /**
+     * Constructs a new Font instance with default values.
+     */
     constructor();
     /**
-     * Set the font family
-     * @param family {string} - The `family` of the font
+     * Sets the font family.
+     * @param family {string} - The `family` of the font.
+     * @returns {this} The current instance for chaining.
+     * @throws {Error} If the family is not provided.
      */
     setFamily(family: string): this;
     /**
-     * Set the font weight
-     * @param weight {AnyWeight} - The `weight` of the font
+     * Sets the font weight.
+     * @param weight {AnyWeight} - The `weight` of the font.
+     * @returns {this} The current instance for chaining.
+     * @throws {Error} If the weight is not provided.
      */
     setWeight(weight: AnyWeight): this;
     /**
-     * Set the path of the font
-     * @param path {string} - The `path` of the font
+     * Sets the file path of the font.
+     * @param path {string} - The `path` of the font.
+     * @returns {this} The current instance for chaining.
+     * @throws {Error} If the path is not provided.
      */
     setPath(path: string): this;
     /**
-     * Set the base64 of the font
-     * @param base64 {string} - The `base64` of the font
+     * Sets the base64 representation of the font.
+     * @param base64 {Buffer} - The `base64` of the font.
+     * @returns {this} The current instance for chaining.
+     * @throws {Error} If the base64 is not provided.
      */
     setBase64(base64: Buffer): this;
     /**
-     * @returns {IFont}
+     * Converts the Font instance to a JSON representation.
+     * @returns {IFont} The JSON representation of the font.
      */
     toJSON(): IFont;
 }