astro-lilypond 1.1.2 → 1.3.0

package/dist/execLilyPond.d.ts

@@ -1,8 +1,9 @@
 import type { AstroIntegrationLogger } from "astro";
-import type { Format } from "./render.js";
+import type { Backend, Format } from "./render.js";
 export interface ExecLilypondOptions {
     binaryPath: string;
     format: Format;
+    backend: Backend;
     crop: boolean;
     resolution: number;
     includePaths: string[];

package/dist/execLilyPond.js

@@ -8,7 +8,7 @@ const MAX_BUFFER = 16 * 1024 * 1024; // 16 MiB
  * build output); throws a normalized Error on a non-zero exit or timeout.
  */
 export async function execLilyPond(options) {
-    const { binaryPath, format, crop, resolution, includePaths, timeout, inputPath, outputBase, logger, } = options;
+    const { binaryPath, format, backend, crop, resolution, includePaths, timeout, inputPath, outputBase, logger, } = options;
     const args = [
         // Render the correct format
         `--format=${format}`,
@@ -20,9 +20,9 @@ export async function execLilyPond(options) {
         // inside of individual .ly files
         // Disable point-and-click behavior on SVGs when clicking noteheads
         "--define-default=no-point-and-click",
-        // Use the `cairo` backend for graphics rendering; faster than the default `ps` backend
+        // `cairo` is faster, but only `ps` supports \postscript markup
         // https://lilypond.org/doc/v2.26/Documentation/usage/advanced-command_002dline-options-for-lilypond
-        "--define-default=backend=cairo",
+        `--define-default=backend=${backend}`,
         // Resolution for generating PNGs (set in DPI)
         `--define-default=resolution=${resolution}`,
         // Set cropping

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import type { AstroIntegration } from "astro";
 import { type AstroComponentFactory } from "astro/runtime/server/index.js";
 import { type AutoInstallOptions } from "./binary/index.js";
 import { type PluginOptions } from "./plugins/index.js";
-import { type LilypondDefaults } from "./render.js";
-import { type LilypondMetadata } from "./utils/index.js";
+import { type Backend, type LilypondDefaults } from "./render.js";
+import { type LilypondMetadata, type RenderedHtmlOptions } from "./utils/index.js";
 export declare const LY_EXTENSIONS: readonly [".ly", ".lilypond", ".ily"];
 export type { AstroComponentFactory, AutoInstallOptions, LilypondDefaults, LilypondMetadata, PluginOptions as LilypondPluginOptions, };
 export interface LilypondPage {
@@ -29,6 +29,11 @@ export interface GetScoreOptions {
      * @default the `defaults.format` configured on the integration ("svg" unless overridden)
      */
     format?: "svg" | "png";
+    /**
+     * Graphics backend for `Score` and `pdf`.
+     * @default the `defaults.backend` configured on the integration ("cairo" unless overridden)
+     */
+    backend?: Backend;
     /**
      * Crop `Score` to a single tightly-fit image instead of full pages.
      * @default false
@@ -54,18 +59,13 @@ export interface GetScoreResult {
     meta: LilypondMetadata;
     raw: string;
 }
-interface ScoreImageProps {
-    pageLimit?: number;
-    class?: string;
-    style?: string;
-    alt?: string;
-}
+type ScoreImageProps = RenderedHtmlOptions;
 /**
  * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
  * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
  */
 export declare function getScore(score: LilypondScore, options?: GetScoreOptions): Promise<GetScoreResult>;
-export interface ScoreProps extends ScoreImageProps, Pick<GetScoreOptions, "format" | "crop"> {
+export interface ScoreProps extends ScoreImageProps, Pick<GetScoreOptions, "format" | "backend" | "crop"> {
     /**
      * A `LilypondScore` from a `.ly`/`.ily`/`.lilypond` import
      * or a `lilypondLoader()` entry.

package/dist/index.js

@@ -10,11 +10,7 @@ export const LY_EXTENSIONS = [".ly", ".lilypond", ".ily"];
 function createScoreComponent(content) {
     return createComponent((_result, props) => {
         const alt = props.alt ?? content.alt ?? "";
-        const html = renderedHtml(content.pages, alt, {
-            class: props.class,
-            style: props.style,
-            pageLimit: props.pageLimit,
-        });
+        const html = renderedHtml(content.pages, { ...props, alt });
         return renderTemplate `${unescapeHTML(html)}`;
     });
 }
@@ -34,8 +30,10 @@ function createErrorScoreComponent(error, title) {
 export async function getScore(score, options = {}) {
     const state = getLilypondState();
     const { logger } = state;
-    const { resolution, cropScale, format: defaultFormat, } = resolveDefaults(state.defaults);
+    const { resolution, cropScale, backend: defaultBackend, format: defaultFormat, } = resolveDefaults(state.defaults);
     const format = options.format ?? defaultFormat;
+    const backend = options.backend ?? defaultBackend;
+    const defaults = { ...state.defaults, backend };
     const crop = options.crop ?? false;
     try {
         const [{ Score, pages }, pdf] = await Promise.all([
@@ -43,6 +41,7 @@ export async function getScore(score, options = {}) {
                 const pages = await emitLilypondAsset({
                     title: score.assetTitle,
                     format,
+                    backend,
                     source: score.source,
                     resolution,
                     crop,
@@ -51,7 +50,7 @@ export async function getScore(score, options = {}) {
                     render: () => render(score.source, {
                         format,
                         crop,
-                        defaults: state.defaults,
+                        defaults,
                         timeout: state.timeout,
                         binaryPath: state.binaryPath,
                         includePaths: score.includePaths,
@@ -68,11 +67,12 @@ export async function getScore(score, options = {}) {
                 ? emitLilypondPdfAsset({
                     title: score.assetTitle,
                     source: score.source,
+                    backend,
                     binaryPath: state.binaryPath,
                     render: () => render(score.source, {
                         format: "pdf",
                         crop: false,
-                        defaults: state.defaults,
+                        defaults,
                         timeout: state.timeout,
                         binaryPath: state.binaryPath,
                         includePaths: score.includePaths,
@@ -102,8 +102,12 @@ export async function getScore(score, options = {}) {
  * `getScore()` instead when you need those.
  */
 export const Score = createComponent(async (result, props) => {
-    const { content, format, crop, ...imageProps } = props;
-    const { Score: ContentScore } = await getScore(content, { format, crop });
+    const { content, format, backend, crop, ...imageProps } = props;
+    const { Score: ContentScore } = await getScore(content, {
+        format,
+        backend,
+        crop,
+    });
     return renderTemplate `${renderComponent(result, "Score", ContentScore, imageProps)}`;
 });
 function injectMarkdownPlugin(processor, key, plugin) {

package/dist/plugins/renderMarkdownBlock.js

@@ -9,13 +9,14 @@ import { altTextForBlock, emitLilypondAsset, prependVersion, renderedErrorHtml,
 export async function renderMarkdownBlock(options, block) {
     const { logger } = options;
     const { title } = block;
-    const { version, format, resolution, cropScale } = resolveDefaults(options.defaults);
+    const { version, format, backend, resolution, cropScale } = resolveDefaults(options.defaults);
     const source = version ? prependVersion(block.value, version) : block.value;
     const alt = altTextForBlock(block.meta, block.value);
     try {
         const pages = await emitLilypondAsset({
             title,
             format,
+            backend,
             source,
             resolution,
             crop: true,
@@ -32,7 +33,7 @@ export async function renderMarkdownBlock(options, block) {
                 logger,
             }),
         });
-        return renderedHtml(pages, alt);
+        return renderedHtml(pages, { alt });
     }
     catch (err) {
         if (!options.isDev)

package/dist/render.d.ts

@@ -2,6 +2,8 @@ import type { AstroIntegrationLogger } from "astro";
 import type { LilypondVersion } from "./types/lilypondVersion.js";
 export declare const FORMATS: readonly ["png", "svg", "pdf"];
 export type Format = (typeof FORMATS)[number];
+export declare const BACKENDS: readonly ["cairo", "ps"];
+export type Backend = (typeof BACKENDS)[number];
 /**
  * Defaults passed to each score for rendering.
  */
@@ -17,6 +19,12 @@ export interface LilypondDefaults {
      * @default "svg"
      */
     format?: "svg" | "png";
+    /**
+     * Graphics backend. `"cairo"` is recommended for faster output.
+     * `"ps"` is required for `\postscript` markup, and can't produce SVG.
+     * @default "cairo"
+     */
+    backend?: Backend;
     /**
      * Resolution in DPI (only applies to PNG).
      * @default 144

package/dist/render.js

@@ -5,9 +5,11 @@ import { execLilyPond } from "./execLilyPond.js";
 import { readOutputFile, safeInputFileName } from "./readOutputFile.js";
 import { resolveDefaults } from "./utils/resolveDefaults.js";
 export const FORMATS = ["png", "svg", "pdf"];
+export const BACKENDS = ["cairo", "ps"];
 const defaultLilypondDefaults = {
     version: "2.26.0",
     format: "svg",
+    backend: "cairo",
     resolution: 144,
     cropScale: 1.5,
 };
@@ -20,10 +22,16 @@ export const defaultOptions = {
 };
 export async function render(source, options) {
     const { format = defaultOptions.format, crop = defaultOptions.crop, binaryPath = defaultOptions.binaryPath, timeout = defaultOptions.timeout, includePaths = [], sourceName, logger, } = options;
-    const { resolution } = resolveDefaults(options.defaults);
+    const { backend, resolution } = resolveDefaults(options.defaults);
     if (!FORMATS.includes(format)) {
         throw new Error(`${format} is not a supported format`);
     }
+    if (!BACKENDS.includes(backend)) {
+        throw new Error(`${backend} is not a supported backend`);
+    }
+    if (backend === "ps" && format === "svg") {
+        throw new Error('The "ps" backend can\'t render SVG; use format "png" or backend "cairo"');
+    }
     const dir = await mkdtemp(join(tmpdir(), "astro-lilypond-"));
     const inputPath = join(dir, safeInputFileName(sourceName));
     const outputBase = join(dir, "output");
@@ -32,6 +40,7 @@ export async function render(source, options) {
         await execLilyPond({
             binaryPath,
             format,
+            backend,
             crop,
             resolution,
             includePaths,

package/dist/utils/emitLilypondAsset.d.ts

@@ -1,8 +1,9 @@
 import type { LilypondPage } from "../index.js";
-import type { Format } from "../render.js";
+import type { Backend, Format } from "../render.js";
 export interface EmitLilypondAssetOptions {
     title: string;
     format: Format;
+    backend: Backend;
     source: string;
     resolution: number;
     crop: boolean;

package/dist/utils/emitLilypondAsset.js

@@ -4,8 +4,8 @@ export async function emitLilypondAsset(options) {
     if (!options.binaryPath) {
         throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
     }
-    const { title, format, source, resolution, crop, sizeScale, render } = options;
-    const assets = await emitAsset(`${title}.[hash].${format}`, [source, format, resolution, crop, sizeScale], async () => {
+    const { title, format, backend, source, resolution, crop, sizeScale, render, } = options;
+    const assets = await emitAsset(`${title}.[hash].${format}`, [source, format, backend, resolution, crop, sizeScale], async () => {
         const buffers = await render();
         return buffers.map((data) => {
             const dimensions = imageDimensionsFor(format, data);

package/dist/utils/emitLilypondPdfAsset.d.ts

@@ -1,7 +1,9 @@
 import type { LilypondPdfResult } from "../index.js";
+import type { Backend } from "../render.js";
 export interface EmitLilypondPdfAssetOptions {
     title: string;
     source: string;
+    backend: Backend;
     binaryPath: string | undefined;
     render: () => Promise<Buffer[]>;
 }

package/dist/utils/emitLilypondPdfAsset.js

@@ -3,8 +3,8 @@ export async function emitLilypondPdfAsset(options) {
     if (!options.binaryPath) {
         throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
     }
-    const { title, source, render } = options;
-    const asset = await emitAsset(`${title}.[hash].pdf`, [source, "pdf"], async () => {
+    const { title, source, backend, render } = options;
+    const asset = await emitAsset(`${title}.[hash].pdf`, [source, "pdf", backend], async () => {
         const [data] = await render();
         return { data };
     });

package/dist/utils/index.d.ts

@@ -16,7 +16,7 @@ export type { LyHeaderFields } from "./parseLyHeader.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
 export { prependVersion } from "./prependVersion.js";
 export { renderedErrorHtml } from "./renderedErrorHtml.js";
-export { renderedHtml } from "./renderedHtml.js";
+export { type RenderedHtmlOptions, renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";
 export { titleFor } from "./titleFor.js";

package/dist/utils/renderedHtml.d.ts

@@ -1,5 +1,6 @@
+import type { HTMLAttributes } from "astro/types";
 import type { LilypondPage } from "../index.js";
-export interface RenderedHtmlOptions {
+export interface RenderedHtmlOptions extends Partial<Pick<HTMLAttributes<"img">, "alt" | "loading" | "decoding" | "fetchpriority">> {
     /** Class applied to the outer `<img>` or `<ol>` tag. */
     class?: string;
     /** Inline styles applied to the outer `<img>` or `<ol>`. */
@@ -7,4 +8,4 @@ export interface RenderedHtmlOptions {
     /** Render only the first `n` pages. */
     pageLimit?: number;
 }
-export declare function renderedHtml(pages: LilypondPage[], alt: string, options?: RenderedHtmlOptions): string;
+export declare function renderedHtml(pages: LilypondPage[], options?: RenderedHtmlOptions): string;

package/dist/utils/renderedHtml.js

@@ -1,19 +1,23 @@
 import { addAttribute } from "astro/runtime/server/index.js";
-function imgTag(page, alt) {
-    return `<img data-lilypond-image${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(alt, "alt")}>`;
+function imgTag(page, alt, imageAttrs) {
+    return `<img data-lilypond-image${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(alt, "alt")}${imageAttrs}>`;
 }
-export function renderedHtml(pages, alt, options = {}) {
-    const { class: className, style, pageLimit } = options;
+export function renderedHtml(pages, options = {}) {
+    const { alt, class: className, style, pageLimit, loading, decoding, fetchpriority, } = options;
+    const resolvedAlt = alt ?? "";
     const limitedPages = pageLimit === undefined ? pages : pages.slice(0, pageLimit);
     if (limitedPages.length === 0)
         return "";
     const classAttr = addAttribute(className, "class");
     const styleAttr = addAttribute(style, "style");
+    const imageAttrs = addAttribute(loading, "loading") +
+        addAttribute(decoding, "decoding") +
+        addAttribute(fetchpriority, "fetchpriority");
     if (limitedPages.length === 1) {
         const page = limitedPages[0];
-        return `<img data-lilypond-image${classAttr}${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(alt, "alt")}${styleAttr}>`;
+        return `<img data-lilypond-image${classAttr}${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(resolvedAlt, "alt")}${imageAttrs}${styleAttr}>`;
     }
     return `<ol data-lilypond-group${classAttr}${styleAttr}>${limitedPages
-        .map((page) => `<li>${imgTag(page, alt)}</li>`)
+        .map((page) => `<li>${imgTag(page, resolvedAlt, imageAttrs)}</li>`)
         .join("")}</ol>`;
 }

package/dist/utils/resolveDefaults.js

@@ -1,10 +1,11 @@
 import { defaultOptions } from "../render.js";
 /** Fills in any `defaults` fields left unset with `render.ts`'s own defaults. */
 export function resolveDefaults(defaults) {
-    const { version, format, resolution, cropScale } = defaultOptions.defaults;
+    const { version, format, backend, resolution, cropScale } = defaultOptions.defaults;
     return {
         version: defaults?.version ?? version,
         format: defaults?.format ?? format,
+        backend: defaults?.backend ?? backend,
         resolution: defaults?.resolution ?? resolution,
         cropScale: defaults?.cropScale ?? cropScale,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -46,8 +46,8 @@
     "utils"
   ],
   "peerDependencies": {
-    "astro": ">=7.0.0",
-    "@astrojs/markdown-remark": ">=7.0.0"
+    "@astrojs/markdown-remark": ">=7.0.0",
+    "astro": ">=7.0.0"
   },
   "peerDependenciesMeta": {
     "@astrojs/markdown-remark": {
@@ -59,17 +59,17 @@
     "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {
-    "@astrojs/markdown-remark": "^7.2.2",
-    "@astrojs/markdown-satteri": "^0.3.5",
+    "@astrojs/markdown-remark": "^7.3.1",
+    "@astrojs/markdown-satteri": "^0.4.2",
     "@types/mdast": "^4.0.4",
-    "@types/node": "^26.1.1",
-    "@vitest/coverage-v8": "^4.1.10",
-    "astro": "^7.1.6",
-    "satteri": "^0.9.5",
+    "@types/node": "^26.6.3",
+    "@vitest/coverage-v8": "^5.0.2",
+    "astro": "^7.3.5",
+    "satteri": "^0.10.5",
     "typescript": "^7.0.2",
     "unified": "^11.0.5",
-    "vite": "^8.0.0",
-    "vitest": "^4.1.10"
+    "vite": "^8.3.1",
+    "vitest": "^5.0.2"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",