xpict 0.0.3 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marcuth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,35 @@
-# Xpict: Generation of standardized images from predefined templates and functions
+# Xpict
+
+Xpict é uma biblioteca para a geração de imagens padronizadas a partir de modelos declarativos.
+
+## Instalação 
+
+```bash
+npm install xpict
+```
+
+## Uso
+
+```typescript
+import xpict from "xpict"
+
+const template = xpict.template({ // para criar um template
+    config: {
+        width: 100, // para definir a largura da imagem
+        height: 100, // para definir a altura da imagem
+        fill: "#fff" // para definir a cor de fundo da imagem
+    },
+    layers: [
+        xpict.rectangle({...}), // para inserir um retângulo
+        xpict.circle({...}), // para inserir um círculo
+        xpict.line({...}), // para inserir uma linha
+        xpict.text({...}), // para inserir texto
+        xpict.image({...}), // para inserir uma imagem
+        xpict.repeat({...}), // para repetir um tipo de camada com base em itens de um array
+        xpict.group({...}) // para agrupar camadas que compoem algo maior
+    ]
+})
+
+const image = await template.render({...}) // para renderizar a imagem passando os dados de entrada
+```
+

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { GroupLayer, RepeatLayer, GroupLayerOptions, ImageLayer, ImageLayerOptions, LineLayer, LineLayerOptions, RectangleLayer, RectangleLayerOptions, RepeatLayerOptions, TextLayer, TextLayerOptions, CircleLayerOptions, CircleLayer } from "./layers";
+import { Template, TemplateOptions } from "./template";
+import { fontConfig } from "./utils/font-config";
+declare const xpict: {
+    rectangle<Data>(options: RectangleLayerOptions<Data>): RectangleLayer<Data>;
+    circle<Data>(options: CircleLayerOptions<Data>): CircleLayer<Data>;
+    text<Data>(options: TextLayerOptions<Data>): TextLayer<Data>;
+    image<Data>(options: ImageLayerOptions<Data>): ImageLayer<Data>;
+    repeat<Data, Item>(options: RepeatLayerOptions<Data, Item>): RepeatLayer<Data, Item>;
+    group<Data>(options: GroupLayerOptions<Data>): GroupLayer<Data>;
+    line<Data>(options: LineLayerOptions<Data>): LineLayer<Data>;
+    template<Data>(options: TemplateOptions<Data>): Template<Data>;
+    fontConfig: typeof fontConfig;
+};
+export default xpict;

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const layers_1 = require("./layers");
+const template_1 = require("./template");
+const font_config_1 = require("./utils/font-config");
+const xpict = {
+    rectangle(options) {
+        return new layers_1.RectangleLayer(options);
+    },
+    circle(options) {
+        return new layers_1.CircleLayer(options);
+    },
+    text(options) {
+        return new layers_1.TextLayer(options);
+    },
+    image(options) {
+        return new layers_1.ImageLayer(options);
+    },
+    repeat(options) {
+        return new layers_1.RepeatLayer(options);
+    },
+    group(options) {
+        return new layers_1.GroupLayer(options);
+    },
+    line(options) {
+        return new layers_1.LineLayer(options);
+    },
+    template(options) {
+        return new template_1.Template(options);
+    },
+    fontConfig: font_config_1.fontConfig
+};
+exports.default = xpict;

package/dist/layers/circle-layer.d.ts

@@ -0,0 +1,15 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type CircleLayerOptions<Data> = {
+    x: Axis<Data>;
+    y: Axis<Data>;
+    radius: number;
+    fill: string;
+    when?: (data: Data, index?: number) => boolean;
+};
+export declare class CircleLayer<Data> extends Layer<Data> {
+    private readonly options;
+    constructor(options: CircleLayerOptions<Data>);
+    render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/circle-layer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircleLayer = void 0;
+const canvas_1 = require("canvas");
+const resolve_axis_1 = require("../utils/resolve-axis");
+const layer_1 = require("./layer");
+class CircleLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data, index = 0) {
+        const image = ctx.image;
+        const metadata = await image.metadata();
+        const canvasWidth = metadata.width;
+        const canvasHeight = metadata.height;
+        const x = ctx.offsetX + (0, resolve_axis_1.resolveAxis)(this.options.x, data, index);
+        const y = ctx.offsetY + (0, resolve_axis_1.resolveAxis)(this.options.y, data, index);
+        const { radius, fill } = this.options;
+        const canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
+        const context = canvas.getContext("2d");
+        context.beginPath();
+        context.arc(x, y, radius, 0, Math.PI * 2);
+        context.closePath();
+        context.fillStyle = fill;
+        context.fill();
+        const circleBuffer = canvas.toBuffer();
+        ctx.image = image.composite([
+            {
+                input: circleBuffer,
+                top: 0,
+                left: 0
+            }
+        ]);
+    }
+}
+exports.CircleLayer = CircleLayer;

package/dist/layers/group-layer.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from "./layer";
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+export type GroupLayerOptions<Data> = {
+    layers: Layer<Data>[];
+    x: Axis<Data>;
+    y: Axis<Data>;
+    when?: (data: Data) => boolean;
+};
+export declare class GroupLayer<Data> extends Layer<Data> {
+    private readonly options;
+    constructor(options: GroupLayerOptions<Data>);
+    render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/group-layer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupLayer = void 0;
+const layer_1 = require("./layer");
+const resolve_axis_1 = require("../utils/resolve-axis");
+const commit_frame_1 = require("../utils/commit-frame");
+class GroupLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data, index = 0) {
+        const dx = (0, resolve_axis_1.resolveAxis)(this.options.x, data, index);
+        const dy = (0, resolve_axis_1.resolveAxis)(this.options.y, data, index);
+        const prevX = ctx.offsetX;
+        const prevY = ctx.offsetY;
+        ctx.offsetX += dx;
+        ctx.offsetY += dy;
+        for (const layer of this.options.layers) {
+            if (!layer.shouldRender(data))
+                continue;
+            await layer.render(ctx, data, index);
+            ctx.image = await (0, commit_frame_1.commitFrame)(ctx.image);
+        }
+        ctx.offsetX = prevX;
+        ctx.offsetY = prevY;
+    }
+}
+exports.GroupLayer = GroupLayer;

package/dist/layers/image-layer.d.ts

@@ -0,0 +1,16 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type ImageLayerOptions<Data> = {
+    src: (data: Data) => string | Buffer;
+    x: Axis<Data>;
+    y: Axis<Data>;
+    width?: number;
+    height?: number;
+    when?: (data: Data) => boolean;
+};
+export declare class ImageLayer<Data> extends Layer<Data> {
+    private options;
+    constructor(options: ImageLayerOptions<Data>);
+    render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/image-layer.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageLayer = void 0;
+const sharp_1 = __importDefault(require("sharp"));
+const resolve_axis_1 = require("../utils/resolve-axis");
+const layer_1 = require("./layer");
+class ImageLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data, index = 0) {
+        const localX = (0, resolve_axis_1.resolveAxis)(this.options.x, data, index);
+        const localY = (0, resolve_axis_1.resolveAxis)(this.options.y, data, index);
+        const x = ctx.offsetX + localX;
+        const y = ctx.offsetY + localY;
+        const img = await (0, sharp_1.default)(this.options.src(data))
+            .resize(this.options.width, this.options.height)
+            .toBuffer();
+        ctx.image = ctx.image.composite([
+            { input: img, left: x, top: y }
+        ]);
+    }
+}
+exports.ImageLayer = ImageLayer;

package/dist/layers/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./group-layer";
+export * from "./image-layer";
+export * from "./repeat-layer";
+export * from "./text-layer";
+export * from "./rectangle-layer";
+export * from "./circle-layer";
+export * from "./line-layer";
+export * from "./layer";

package/dist/layers/index.js

@@ -0,0 +1,24 @@
+"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("./group-layer"), exports);
+__exportStar(require("./image-layer"), exports);
+__exportStar(require("./repeat-layer"), exports);
+__exportStar(require("./text-layer"), exports);
+__exportStar(require("./rectangle-layer"), exports);
+__exportStar(require("./circle-layer"), exports);
+__exportStar(require("./line-layer"), exports);
+__exportStar(require("./layer"), exports);

package/dist/layers/layer.d.ts

@@ -0,0 +1,7 @@
+import { RenderContext } from "../render-context";
+export declare abstract class Layer<Data = any> {
+    protected readonly when?: ((data: Data, index?: number) => boolean) | undefined;
+    constructor(when?: ((data: Data, index?: number) => boolean) | undefined);
+    shouldRender(data: Data, index?: number): boolean;
+    abstract render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/layer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layer = void 0;
+class Layer {
+    constructor(when) {
+        this.when = when;
+    }
+    shouldRender(data, index = 0) {
+        return this.when ? this.when(data, index) : true;
+    }
+}
+exports.Layer = Layer;

package/dist/layers/line-layer.d.ts

@@ -0,0 +1,21 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type LineLayerOptions<Data> = {
+    from: {
+        x: Axis<Data>;
+        y: Axis<Data>;
+    };
+    to: {
+        x: Axis<Data>;
+        y: Axis<Data>;
+    };
+    color: string;
+    width: number;
+    when?: (data: Data, index?: number) => boolean;
+};
+export declare class LineLayer<Data> extends Layer<Data> {
+    private readonly options;
+    constructor(options: LineLayerOptions<Data>);
+    render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/line-layer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineLayer = void 0;
+const canvas_1 = require("canvas");
+const resolve_axis_1 = require("../utils/resolve-axis");
+const layer_1 = require("./layer");
+class LineLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data, index = 0) {
+        const image = ctx.image;
+        const metadata = await image.metadata();
+        const canvasWidth = metadata.width;
+        const canvasHeight = metadata.height;
+        const x1 = ctx.offsetX + (0, resolve_axis_1.resolveAxis)(this.options.from.x, data, index);
+        const y1 = ctx.offsetY + (0, resolve_axis_1.resolveAxis)(this.options.from.y, data, index);
+        const x2 = ctx.offsetX + (0, resolve_axis_1.resolveAxis)(this.options.to.x, data, index);
+        const y2 = ctx.offsetY + (0, resolve_axis_1.resolveAxis)(this.options.to.y, data, index);
+        const canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
+        const context = canvas.getContext("2d");
+        context.strokeStyle = this.options.color;
+        context.lineWidth = this.options.width;
+        context.lineCap = "round";
+        context.beginPath();
+        context.moveTo(x1, y1);
+        context.lineTo(x2, y2);
+        context.stroke();
+        const lineBuffer = canvas.toBuffer();
+        ctx.image = image.composite([
+            {
+                input: lineBuffer,
+                top: 0,
+                left: 0
+            }
+        ]);
+    }
+}
+exports.LineLayer = LineLayer;

package/dist/layers/rectangle-layer.d.ts

@@ -0,0 +1,16 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type RectangleLayerOptions<Data> = {
+    x: Axis<Data>;
+    y: Axis<Data>;
+    width: number;
+    height: number;
+    fill: string;
+    borderRadius?: number;
+};
+export declare class RectangleLayer<Data> extends Layer<Data> {
+    private readonly options;
+    constructor(options: RectangleLayerOptions<Data>, when?: (data: Data, index?: number) => boolean);
+    render(ctx: RenderContext, data: Data, index?: number): Promise<void>;
+}

package/dist/layers/rectangle-layer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RectangleLayer = void 0;
+const canvas_1 = require("canvas");
+const resolve_axis_1 = require("../utils/resolve-axis");
+const layer_1 = require("./layer");
+class RectangleLayer extends layer_1.Layer {
+    constructor(options, when) {
+        super(when);
+        this.options = options;
+    }
+    async render(ctx, data, index = 0) {
+        const image = ctx.image;
+        const metadata = await image.metadata();
+        const canvasWidth = metadata.width;
+        const canvasHeight = metadata.height;
+        const localX = (0, resolve_axis_1.resolveAxis)(this.options.x, data, index);
+        const localY = (0, resolve_axis_1.resolveAxis)(this.options.y, data, index);
+        const x = ctx.offsetX + localX;
+        const y = ctx.offsetY + localY;
+        const { width, height, fill, borderRadius } = this.options;
+        const canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
+        const context = canvas.getContext("2d");
+        context.fillStyle = fill;
+        if (borderRadius && borderRadius > 0) {
+            const r = Math.min(borderRadius, width / 2, height / 2);
+            context.beginPath();
+            context.moveTo(x + r, y);
+            context.lineTo(x + width - r, y);
+            context.arcTo(x + width, y, x + width, y + height, r);
+            context.lineTo(x + width, y + height - r);
+            context.arcTo(x + width, y + height, x, y + height, r);
+            context.lineTo(x + r, y + height);
+            context.arcTo(x, y + height, x, y, r);
+            context.lineTo(x, y + r);
+            context.arcTo(x, y, x + width, y, r);
+            context.closePath();
+            context.fill();
+        }
+        else {
+            context.fillRect(x, y, width, height);
+        }
+        const rectangleBuffer = canvas.toBuffer();
+        ctx.image = image.composite([
+            {
+                input: rectangleBuffer,
+                top: 0,
+                left: 0
+            }
+        ]);
+    }
+}
+exports.RectangleLayer = RectangleLayer;

package/dist/layers/repeat-layer.d.ts

@@ -0,0 +1,15 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type RepeatLayerOptions<Data, Item> = {
+    each: (data: Data) => Item[];
+    layer: (item: Item, index: number) => Layer<Data>;
+    when?: (data: Data) => boolean;
+    x: Axis<Data>;
+    y: Axis<Data>;
+};
+export declare class RepeatLayer<Data, Item> extends Layer<Data> {
+    private readonly options;
+    constructor(options: RepeatLayerOptions<Data, Item>);
+    render(ctx: RenderContext, data: Data): Promise<void>;
+}

package/dist/layers/repeat-layer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatLayer = void 0;
+const resolve_axis_1 = require("../utils/resolve-axis");
+const commit_frame_1 = require("../utils/commit-frame");
+const layer_1 = require("./layer");
+class RepeatLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data) {
+        const items = this.options.each(data);
+        if (!items || items.length === 0)
+            return;
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const dx = (0, resolve_axis_1.resolveAxis)(this.options.x, data, index);
+            const dy = (0, resolve_axis_1.resolveAxis)(this.options.y, data, index);
+            const prevX = ctx.offsetX;
+            const prevY = ctx.offsetY;
+            ctx.offsetX += dx;
+            ctx.offsetY += dy;
+            const layer = this.options.layer(item, index);
+            await layer.render(ctx, data, index);
+            ctx.image = await (0, commit_frame_1.commitFrame)(ctx.image);
+            ctx.offsetX = prevX;
+            ctx.offsetY = prevY;
+        }
+    }
+}
+exports.RepeatLayer = RepeatLayer;

package/dist/layers/text-layer.d.ts

@@ -0,0 +1,30 @@
+import { Axis } from "../utils/resolve-axis";
+import { RenderContext } from "../render-context";
+import { Layer } from "./layer";
+export type FontOptions = {
+    size: number;
+    color?: string;
+    name?: string;
+    filePath?: string;
+};
+export type TextAnchor = "top-left" | "top-center" | "top-right" | "middle-left" | "middle-center" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right";
+export type Stroke = {
+    fill: string;
+    width: number;
+};
+export type TextLayerOptions<Data> = {
+    text: (data: Data) => string;
+    font: FontOptions;
+    x: Axis<Data>;
+    y: Axis<Data>;
+    backgroundColor?: string;
+    anchor?: TextAnchor;
+    stroke?: Stroke;
+    rotation?: number;
+    when?: (data: Data) => boolean;
+};
+export declare class TextLayer<Data> extends Layer<Data> {
+    private readonly options;
+    constructor(options: TextLayerOptions<Data>);
+    render(ctx: RenderContext, data: Data): Promise<void>;
+}

package/dist/layers/text-layer.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextLayer = void 0;
+const canvas_1 = require("canvas");
+const resolve_axis_1 = require("../utils/resolve-axis");
+const layer_1 = require("./layer");
+const anchorOffsets = {
+    "top-left": (w, h) => ({ x: 0, y: 0 }),
+    "top-center": (w, h) => ({ x: -w / 2, y: 0 }),
+    "top-right": (w, h) => ({ x: -w, y: 0 }),
+    "middle-left": (w, h) => ({ x: 0, y: -h / 2 }),
+    "middle-center": (w, h) => ({ x: -w / 2, y: -h / 2 }),
+    "middle-right": (w, h) => ({ x: -w, y: -h / 2 }),
+    "bottom-left": (w, h) => ({ x: 0, y: -h }),
+    "bottom-center": (w, h) => ({ x: -w / 2, y: -h }),
+    "bottom-right": (w, h) => ({ x: -w, y: -h })
+};
+class TextLayer extends layer_1.Layer {
+    constructor(options) {
+        super(options.when);
+        this.options = options;
+    }
+    async render(ctx, data) {
+        var _a, _b;
+        const imageMetadata = await ctx.image.metadata();
+        const width = imageMetadata.width;
+        const height = imageMetadata.height;
+        const { text, font, x: initialX, y: initialY, backgroundColor = "transparent", anchor = "top-left", stroke, rotation = 0 } = this.options;
+        if (font.filePath) {
+            (0, canvas_1.registerFont)(font.filePath, { family: font.name });
+        }
+        const canvas = (0, canvas_1.createCanvas)(width, height);
+        const context = canvas.getContext("2d");
+        if (backgroundColor !== "transparent") {
+            context.fillStyle = backgroundColor;
+            context.fillRect(0, 0, width, height);
+        }
+        context.font = `${font.size}px ${(_a = font.name) !== null && _a !== void 0 ? _a : "Arial"}`;
+        context.fillStyle = (_b = font.color) !== null && _b !== void 0 ? _b : "#000";
+        const content = text(data);
+        const metrics = context.measureText(content);
+        const textWidth = metrics.width;
+        const textHeight = font.size;
+        const offset = anchorOffsets[anchor](textWidth, textHeight);
+        const localX = (0, resolve_axis_1.resolveAxis)(initialX, data, 0);
+        const localY = (0, resolve_axis_1.resolveAxis)(initialY, data, 0);
+        const x = ctx.offsetX + localX;
+        const y = ctx.offsetY + localY;
+        const adjustedX = x + offset.x;
+        const adjustedY = y + offset.y;
+        context.save();
+        context.translate(adjustedX, adjustedY);
+        context.rotate((rotation * Math.PI) / 180);
+        if (stroke) {
+            context.strokeStyle = stroke.fill;
+            context.lineWidth = stroke.width;
+            context.lineJoin = "round";
+            context.strokeText(content, 0, 0);
+        }
+        context.fillText(content, 0, 0);
+        context.restore();
+        const buffer = canvas.toBuffer();
+        ctx.image = ctx.image.composite([
+            { input: buffer, top: 0, left: 0 }
+        ]);
+    }
+}
+exports.TextLayer = TextLayer;

package/dist/render-context.d.ts

@@ -0,0 +1,6 @@
+import sharp from "sharp";
+export type RenderContext = {
+    image: sharp.Sharp;
+    offsetX: number;
+    offsetY: number;
+};

package/dist/render-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/template.d.ts

@@ -0,0 +1,21 @@
+import sharp, { Color } from "sharp";
+import { Layer } from "./layers/layer";
+export type TemplateConfig = {
+    width: number;
+    height: number;
+    fill?: Color;
+};
+export type TemplateOptions<Data> = {
+    imagePath: undefined;
+    config: TemplateConfig;
+    layers: Layer<Data>[];
+} | {
+    config: undefined;
+    imagePath: string;
+    layers: Layer<Data>[];
+};
+export declare class Template<Data> {
+    readonly options: TemplateOptions<Data>;
+    constructor(options: TemplateOptions<Data>);
+    render(data: Data): Promise<sharp.Sharp>;
+}