xpict 0.4.1 → 1.0.1

package/dist/layers/group-layer.js

@@ -3,7 +3,6 @@ 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);
@@ -15,13 +14,13 @@ class GroupLayer extends layer_1.Layer {
             axis: (_a = this.options.x) !== null && _a !== void 0 ? _a : 0,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
         const dy = (0, resolve_axis_1.resolveAxis)({
             axis: (_b = this.options.y) !== null && _b !== void 0 ? _b : 0,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
         const prevX = ctx.offsetX;
         const prevY = ctx.offsetY;
@@ -36,7 +35,6 @@ class GroupLayer extends layer_1.Layer {
                 index: index,
                 templateConfig: templateConfig,
             });
-            ctx.image = await (0, commit_frame_1.commitFrame)(ctx.image);
         }
         ctx.offsetX = prevX;
         ctx.offsetY = prevY;

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

@@ -1,12 +1,13 @@
-import sharp from "sharp";
+import { Canvas, SKRSContext2D } from "@napi-rs/canvas";
 import { Layer, RenderOptions, WhenFunction } from "./layer";
 import { Axis } from "../utils/resolve-axis";
 export type TransformOptions<Data> = {
     data: Data;
     index: number;
-    image: sharp.Sharp;
+    canvas: Canvas;
+    ctx: SKRSContext2D;
 };
-export type ImageTransformFunction<Data> = (options: TransformOptions<Data>) => sharp.Sharp | Promise<sharp.Sharp>;
+export type ImageTransformFunction<Data> = (options: TransformOptions<Data>) => void | Promise<void>;
 export type ImageImageSrcOptions<Data> = {
     data: Data;
     index: number;
@@ -27,5 +28,5 @@ export type ImageLayerOptions<Data> = {
 export declare class ImageLayer<Data> extends Layer<Data> {
     private options;
     constructor(options: ImageLayerOptions<Data>);
-    render({ context: ctx, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
+    render({ context: renderContext, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
 }

package/dist/layers/image-layer.js

@@ -1,10 +1,7 @@
 "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 canvas_1 = require("@napi-rs/canvas");
 const layer_1 = require("./layer");
 const resolve_axis_1 = require("../utils/resolve-axis");
 const error_1 = require("../error");
@@ -13,47 +10,54 @@ class ImageLayer extends layer_1.Layer {
         super(options.when);
         this.options = options;
     }
-    async render({ context: ctx, data, index = 0, templateConfig }) {
+    async render({ context: renderContext, data, index = 0, templateConfig }) {
         const localX = (0, resolve_axis_1.resolveAxis)({
             axis: this.options.x,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
         const localY = (0, resolve_axis_1.resolveAxis)({
             axis: this.options.y,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
-        const x = ctx.offsetX + localX;
-        const y = ctx.offsetY + localY;
+        const x = renderContext.offsetX + localX;
+        const y = renderContext.offsetY + localY;
         const src = this.options.src;
         const resolvedImageSource = typeof src === "string" ? src : src({ data: data, index: index });
+        const image = await (0, canvas_1.loadImage)(resolvedImageSource);
+        const localCanvas = (0, canvas_1.createCanvas)(image.width, image.height);
+        const localContext = localCanvas.getContext("2d");
         try {
-            let img = (0, sharp_1.default)(resolvedImageSource).resize(this.options.width, this.options.height);
+            localContext.drawImage(image, 0, 0);
             if (this.options.flipX) {
-                img = img.flop();
+                localContext.translate(image.width, 0);
+                localContext.scale(-1, 1);
             }
             if (this.options.flipY) {
-                img = img.flip();
+                localContext.translate(0, image.height);
+                localContext.scale(1, -1);
             }
             if (this.options.rotate !== undefined) {
-                img = img.rotate(this.options.rotate, {
-                    background: { r: 0, g: 0, b: 0, alpha: 0 },
-                });
+                localContext.translate(image.width / 2, image.height / 2);
+                localContext.rotate((this.options.rotate * Math.PI) / 180);
+                localContext.translate(-image.width / 2, -image.height / 2);
             }
             if (this.options.transform && this.options.transform.length > 0) {
                 for (const transform of this.options.transform) {
-                    img = await transform({
+                    await transform({
                         data: data,
                         index: index,
-                        image: img,
+                        canvas: localCanvas,
+                        ctx: localContext,
                     });
                 }
             }
-            const buffer = await img.toBuffer();
-            ctx.image = ctx.image.composite([{ input: buffer, left: x, top: y }]);
+            const buffer = localCanvas.toBuffer("image/png");
+            const finalImage = await (0, canvas_1.loadImage)(buffer);
+            renderContext.ctx.drawImage(finalImage, x, y);
         }
         catch (error) {
             throw new error_1.XpictError(`Failed to render image layer (${resolvedImageSource}): ${error.message}`);

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

@@ -16,5 +16,5 @@ export type LineLayerOptions<Data> = {
 export declare class LineLayer<Data> extends Layer<Data> {
     private readonly options;
     constructor(options: LineLayerOptions<Data>);
-    render({ context: ctx, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
+    render({ context: renderContext, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
 }

package/dist/layers/line-layer.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineLayer = void 0;
-const canvas_1 = require("canvas");
 const layer_1 = require("./layer");
 const resolve_axis_1 = require("../utils/resolve-axis");
 class LineLayer extends layer_1.Layer {
@@ -9,41 +8,36 @@ class LineLayer extends layer_1.Layer {
         super(options.when);
         this.options = options;
     }
-    async render({ context: ctx, data, index = 0, templateConfig }) {
-        const image = ctx.image;
-        const metadata = await image.metadata();
-        const canvasWidth = metadata.width;
-        const canvasHeight = metadata.height;
-        const x1 = ctx.offsetX +
+    async render({ context: renderContext, data, index = 0, templateConfig }) {
+        const x1 = renderContext.offsetX +
             (0, resolve_axis_1.resolveAxis)({
                 axis: this.options.from.x,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
-        const y1 = ctx.offsetY +
+        const y1 = renderContext.offsetY +
             (0, resolve_axis_1.resolveAxis)({
                 axis: this.options.from.y,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
-        const x2 = ctx.offsetX +
+        const x2 = renderContext.offsetX +
             (0, resolve_axis_1.resolveAxis)({
                 axis: this.options.to.x,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
-        const y2 = ctx.offsetY +
+        const y2 = renderContext.offsetY +
             (0, resolve_axis_1.resolveAxis)({
                 axis: this.options.to.y,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
-        const canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
-        const context = canvas.getContext("2d");
+        const context = renderContext.ctx;
         context.strokeStyle = this.options.color;
         context.lineWidth = this.options.width;
         context.lineCap = "round";
@@ -51,14 +45,6 @@ class LineLayer extends layer_1.Layer {
         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

@@ -12,5 +12,5 @@ export type RectangleLayerOptions<Data> = {
 export declare class RectangleLayer<Data> extends Layer<Data> {
     private readonly options;
     constructor(options: RectangleLayerOptions<Data>);
-    render({ context: ctx, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
+    render({ context: renderContext, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
 }

package/dist/layers/rectangle-layer.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RectangleLayer = void 0;
-const canvas_1 = require("canvas");
 const layer_1 = require("./layer");
 const resolve_axis_1 = require("../utils/resolve-axis");
 class RectangleLayer extends layer_1.Layer {
@@ -9,28 +8,23 @@ class RectangleLayer extends layer_1.Layer {
         super(options.when);
         this.options = options;
     }
-    async render({ context: ctx, data, index = 0, templateConfig }) {
-        const image = ctx.image;
-        const metadata = await image.metadata();
-        const canvasWidth = metadata.width;
-        const canvasHeight = metadata.height;
+    async render({ context: renderContext, data, index = 0, templateConfig }) {
         const localX = (0, resolve_axis_1.resolveAxis)({
             axis: this.options.x,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
         const localY = (0, resolve_axis_1.resolveAxis)({
             axis: this.options.y,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
-        const x = ctx.offsetX + localX;
-        const y = ctx.offsetY + localY;
+        const x = renderContext.offsetX + localX;
+        const y = renderContext.offsetY + localY;
         const { width, height, fill, borderRadius } = this.options;
-        const canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
-        const context = canvas.getContext("2d");
+        const context = renderContext.ctx;
         context.fillStyle = fill;
         if (borderRadius && borderRadius > 0) {
             const r = Math.min(borderRadius, width / 2, height / 2);
@@ -50,14 +44,6 @@ class RectangleLayer extends layer_1.Layer {
         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.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RepeatLayer = void 0;
 const layer_1 = require("./layer");
 const resolve_axis_1 = require("../utils/resolve-axis");
-const commit_frame_1 = require("../utils/commit-frame");
 class RepeatLayer extends layer_1.Layer {
     constructor(options) {
         super(options.when);
@@ -19,13 +18,13 @@ class RepeatLayer extends layer_1.Layer {
                 axis: this.options.x,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
             const dy = (0, resolve_axis_1.resolveAxis)({
                 axis: this.options.y,
                 data: data,
                 index: index,
-                templateConfig: templateConfig,
+                templateSize: templateConfig,
             });
             const prevX = ctx.offsetX;
             const prevY = ctx.offsetY;
@@ -38,7 +37,6 @@ class RepeatLayer extends layer_1.Layer {
                 index: index,
                 templateConfig: templateConfig,
             });
-            ctx.image = await (0, commit_frame_1.commitFrame)(ctx.image);
             ctx.offsetX = prevX;
             ctx.offsetY = prevY;
         }

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

@@ -1,12 +1,8 @@
 import { Layer, RenderOptions, WhenFunction } from "./layer";
 import { Axis } from "../utils/resolve-axis";
-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";
+import { ValueOfEnum } from "../utils/value-of-enum";
+import { TextBaseline, TextAlign } from "../enums";
+import { Font } from "../utils/font";
 export type Stroke = {
     fill: string;
     width: number;
@@ -16,17 +12,13 @@ export type TextFunctionOptions<Data> = {
     index: number;
 };
 export type StringFunction<Data> = (options: TextFunctionOptions<Data>) => string;
-export type TextAlign = "left" | "center" | "right";
-export type TextBaseline = "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";
 export type TextLayerOptions<Data> = {
     text: StringFunction<Data> | string;
-    font: FontOptions;
+    font: Font;
     x: Axis<Data>;
     y: Axis<Data>;
-    backgroundColor?: string;
-    anchor?: TextAnchor;
-    align?: TextAlign;
-    baseline?: TextBaseline;
+    align?: ValueOfEnum<TextAlign>;
+    baseline?: ValueOfEnum<TextBaseline>;
     stroke?: Stroke;
     rotation?: number;
     when?: WhenFunction<Data>;
@@ -34,5 +26,5 @@ export type TextLayerOptions<Data> = {
 export declare class TextLayer<Data> extends Layer<Data> {
     private readonly options;
     constructor(options: TextLayerOptions<Data>);
-    render({ context: ctx, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
+    render({ context: renderContext, data, index, templateConfig }: RenderOptions<Data>): Promise<void>;
 }

package/dist/layers/text-layer.js

@@ -1,43 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextLayer = void 0;
-const canvas_1 = require("canvas");
 const layer_1 = require("./layer");
 const resolve_axis_1 = require("../utils/resolve-axis");
-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({ context: ctx, data, index = 0, templateConfig }) {
+    async render({ context: renderContext, data, index = 0, templateConfig }) {
         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, align, baseline, } = this.options;
-        if (!font.name) {
-            throw new Error("Font name is required");
-        }
-        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);
-        }
+        const { text, font, x: initialX, y: initialY, stroke, rotation = 0, align, baseline } = this.options;
+        const context = renderContext.ctx;
         if (align) {
             context.textAlign = align;
         }
@@ -47,28 +21,22 @@ class TextLayer extends layer_1.Layer {
         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 = typeof text === "string" ? text : text({ data: data, index: index });
-        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)({
             axis: initialX,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
         const localY = (0, resolve_axis_1.resolveAxis)({
             axis: initialY,
             data: data,
             index: index,
-            templateConfig: templateConfig,
+            templateSize: templateConfig,
         });
-        const x = ctx.offsetX + localX;
-        const y = ctx.offsetY + localY;
-        const adjustedX = x + offset.x;
-        const adjustedY = y + offset.y;
+        const x = renderContext.offsetX + localX;
+        const y = renderContext.offsetY + localY;
         context.save();
-        context.translate(adjustedX, adjustedY);
+        context.translate(x, y);
         context.rotate((rotation * Math.PI) / 180);
         if (stroke) {
             context.strokeStyle = stroke.fill;
@@ -78,8 +46,6 @@ class TextLayer extends layer_1.Layer {
         }
         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

@@ -1,6 +1,6 @@
-import sharp from "sharp";
+import { SKRSContext2D } from "@napi-rs/canvas";
 export type RenderContext = {
-    image: sharp.Sharp;
+    ctx: SKRSContext2D;
     offsetX: number;
     offsetY: number;
 };

package/dist/template.d.ts

@@ -1,9 +1,11 @@
-import sharp, { Color } from "sharp";
+import { Canvas } from "@napi-rs/canvas";
 import { Layer } from "./layers/layer";
-export type TemplateConfig = {
+export type TemplateSize = {
     width: number;
     height: number;
-    fill?: Color;
+};
+export type TemplateConfig = TemplateSize & {
+    fill?: string;
 };
 export type InputTemplateOptions<Data> = {
     imagePath?: undefined;
@@ -22,5 +24,5 @@ export type TemplateOptions<Data> = {
 export declare class Template<Data> {
     readonly options: TemplateOptions<Data>;
     constructor(options: InputTemplateOptions<Data>);
-    render(data: Data): Promise<sharp.Sharp>;
+    render(data: Data): Promise<Canvas>;
 }

package/dist/template.js

@@ -1,44 +1,37 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Template = void 0;
-const sharp_1 = __importDefault(require("sharp"));
-const commit_frame_1 = require("./utils/commit-frame");
-const transparentFill = {
-    r: 0,
-    g: 0,
-    b: 0,
-    alpha: 0,
-};
+const canvas_1 = require("@napi-rs/canvas");
+const error_1 = require("./error");
 class Template {
     constructor(options) {
         this.options = options;
     }
     async render(data) {
-        let image;
+        let canvas;
         if (this.options.config) {
             const { width, height, fill } = this.options.config;
-            image = (0, sharp_1.default)({
-                create: {
-                    width: width,
-                    height: height,
-                    channels: 4,
-                    background: fill !== null && fill !== void 0 ? fill : transparentFill,
-                },
-            });
+            canvas = (0, canvas_1.createCanvas)(width, height);
+            if (fill) {
+                const ctx = canvas.getContext("2d");
+                ctx.fillStyle = fill;
+                ctx.fillRect(0, 0, width, height);
+            }
         }
-        else {
-            image = (0, sharp_1.default)(this.options.imagePath);
-            const metadata = await image.metadata();
+        else if (this.options.imagePath) {
+            const backgroundImage = await (0, canvas_1.loadImage)(this.options.imagePath);
+            canvas = (0, canvas_1.createCanvas)(backgroundImage.width, backgroundImage.height);
             this.options.config = {
-                width: metadata.width,
-                height: metadata.height,
+                width: backgroundImage.width,
+                height: backgroundImage.height,
             };
         }
-        const ctx = {
-            image: image,
+        else {
+            throw new error_1.XpictError("No config or imagePath provided");
+        }
+        const ctx = canvas.getContext("2d");
+        const renderContext = {
+            ctx: ctx,
             offsetX: 0,
             offsetY: 0,
         };
@@ -46,13 +39,12 @@ class Template {
             if (!layer.shouldRender(data))
                 continue;
             await layer.render({
-                context: ctx,
+                context: renderContext,
                 data: data,
                 templateConfig: this.options.config,
             });
-            ctx.image = await (0, commit_frame_1.commitFrame)(ctx.image);
         }
-        return ctx.image;
+        return canvas;
     }
 }
 exports.Template = Template;

package/dist/utils/font.d.ts

@@ -0,0 +1,17 @@
+export type FontOptions = {
+    size: number;
+    color?: string;
+    name?: string;
+    filePath?: string;
+};
+export type FontConfigOptions = {
+    color?: string;
+    name: string;
+    filePath?: string;
+};
+export type PartialFontOptions = {
+    size: number;
+    color?: string;
+};
+export type Font = Omit<FontOptions, "filePath">;
+export declare function font(options: FontConfigOptions): (partialOptions: PartialFontOptions) => Font;

package/dist/utils/font.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.font = font;
+const canvas_1 = require("@napi-rs/canvas");
+const node_fs_1 = __importDefault(require("node:fs"));
+function font(options) {
+    if (options.filePath) {
+        const buffer = node_fs_1.default.readFileSync(options.filePath);
+        canvas_1.GlobalFonts.register(buffer, options.name);
+    }
+    return (partialOptions) => {
+        const { filePath: _, ...rest } = {
+            ...options,
+            ...partialOptions,
+        };
+        return rest;
+    };
+}

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./wrap-text";
-export * from "./font-config";
+export * from "./font";

package/dist/utils/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./wrap-text"), exports);
-__exportStar(require("./font-config"), exports);
+__exportStar(require("./font"), exports);

package/dist/utils/resolve-axis.d.ts

@@ -1,14 +1,12 @@
-import { TemplateConfig } from "../template";
+import { TemplateSize } from "../template";
 export type ComputeAxisOptions<Data> = {
     data: Data;
     index: number;
+    templateSize: TemplateSize;
 };
 export type ComputeAxis<Data> = (options: ComputeAxisOptions<Data>) => number;
 export type Axis<Data> = ComputeAxis<Data> | number;
-export type ResolveAxisOptions<Data> = {
+export type ResolveAxisOptions<Data> = ComputeAxisOptions<Data> & {
     axis: Axis<Data>;
-    data: Data;
-    index: number;
-    templateConfig: TemplateConfig;
 };
 export declare function resolveAxis<Data>({ axis, ...params }: ResolveAxisOptions<Data>): number;

package/dist/utils/value-of-enum.d.ts

@@ -0,0 +1 @@
+export type ValueOfEnum<Enum extends string | number> = Enum | `${Enum}`;

package/dist/utils/value-of-enum.js

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