astro-lilypond 0.16.0 → 0.16.2

package/README.md

@@ -3,7 +3,7 @@
 An [Astro](https://astro.build) integration for rendering [LilyPond](https://lilypond.org) music notation to images.
 
 - Render musical scores via Markdown or with an Astro component.
-- Works with remark, rehype and satteri Markdown processors out-of-the-box.
+- Works with remark and satteri Markdown processors out-of-the-box.
 - Zero client-side JavaScript! Images are compiled at build time.
 - Automatic `alt` text generated from the score’s title and composer. (Or supply your own.)
 - Use the content loader to pass in a folder full of `.ly` files and get back an Astro content collection.

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createComponent, renderComponent, renderTemplate, unescapeHTML, } from "astro/runtime/server/index.js";
 import emitAssetIntegration from "astro-emit-asset";
-import { rehypePlugin, remarkPlugin, satteriPlugin, } from "./plugins/index.js";
+import { remarkPlugin, satteriPlugin, } from "./plugins/index.js";
 import { render as renderScore } from "./render.js";
 import { getRenderState, resolveAndSetRenderState } from "./renderState.js";
 import { altTextFor, emitLilypondAsset, emitLilypondPdfAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeaderFields, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
@@ -162,14 +162,10 @@ export default function lilypond(options = {}) {
                                     ...(existingOptions.remarkPlugins ?? []),
                                     [remarkPlugin, options],
                                 ],
-                                rehypePlugins: [
-                                    ...(existingOptions.rehypePlugins ?? []),
-                                    [rehypePlugin, options],
-                                ],
                             }),
                         },
                     });
-                    logger?.info("astro-lilypond: registered unified remark/rehype plugins");
+                    logger?.info("astro-lilypond: registered unified remark plugin");
                     return;
                 }
                 throw new Error("astro-lilypond requires a processor-based Astro markdown config. " +

package/dist/loader.d.ts

@@ -1,6 +1,5 @@
-import type { Loader } from "astro/loaders";
+import type { LoaderContext } from "astro/loaders";
 import { z } from "astro/zod";
-import type { AutoInstallOptions } from "./binary/index.js";
 import { type LilypondScore } from "./index.js";
 import type { LilypondDefaults } from "./render.js";
 export interface GenerateIdOptions {
@@ -32,27 +31,7 @@ export interface LilypondLoaderOptions {
      * collection's entries.
      */
     defaults?: LilypondDefaults;
-    /**
-     * Milliseconds to wait for a single `lilypond` invocation before
-     * aborting it, when `render()` is later called on one of this
-     * collection's entries.
-     * @default 60000
-     */
-    timeout?: number;
-    /**
-     * When no `lilypond` binary is found on `PATH`, download a matching
-     * prebuilt release into a local cache and use that instead. Set to
-     * `false` to only ever use a `PATH` install, or pass an object to pick
-     * which version gets downloaded.
-     * @default true
-     */
-    autoInstall?: boolean | AutoInstallOptions;
 }
-/**
- * A collection entry is itself a `LilypondScore` (its `meta` carries the
- * file's `\header` fields) — pass `entry.data` directly to the exported
- * `render()`, exactly as you would a plain `.ly` import.
- */
 export type LilypondCollectionEntry = LilypondScore;
 export declare const lilypondEntrySchema: z.ZodObject<{
     source: z.ZodString;
@@ -79,4 +58,29 @@ export declare const lilypondEntrySchema: z.ZodObject<{
 /**
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
-export declare function lilypondLoader(options: LilypondLoaderOptions): Loader;
+export declare function lilypondLoader({ pattern, base, generateId, defaults, }: LilypondLoaderOptions): {
+    name: string;
+    schema: z.ZodObject<{
+        source: z.ZodString;
+        alt: z.ZodString;
+        sourceName: z.ZodOptional<z.ZodString>;
+        includePaths: z.ZodArray<z.ZodString>;
+        assetTitle: z.ZodString;
+        meta: z.ZodObject<{
+            arranger: z.ZodOptional<z.ZodString>;
+            composer: z.ZodOptional<z.ZodString>;
+            copyright: z.ZodOptional<z.ZodString>;
+            dedication: z.ZodOptional<z.ZodString>;
+            instrument: z.ZodOptional<z.ZodString>;
+            meter: z.ZodOptional<z.ZodString>;
+            opus: z.ZodOptional<z.ZodString>;
+            piece: z.ZodOptional<z.ZodString>;
+            poet: z.ZodOptional<z.ZodString>;
+            subsubtitle: z.ZodOptional<z.ZodString>;
+            subtitle: z.ZodOptional<z.ZodString>;
+            tagline: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodString>>;
+    }, z.core.$strip>;
+    load(context: LoaderContext): Promise<void>;
+};

package/dist/loader.js

@@ -3,23 +3,32 @@ import { join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "astro/zod";
 import { LY_EXTENSIONS } from "./index.js";
-import { resolveAndSetRenderState } from "./renderState.js";
-import { altTextFor, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, STANDARD_HEADER_FIELDS, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
+import { altTextFor, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
 const DEFAULT_PATTERN = `**/*.{${LY_EXTENSIONS.map((ext) => ext.slice(1)).join(",")}}`;
-// Built from the same `STANDARD_HEADER_FIELDS` list `KnownLyHeaderFields` is
-// derived from, so the two can't drift. `.catchall()` lets any other header
-// field (e.g. `mutopiacomposer`) sit alongside the standard ones, typed as
-// `string` — matching `LilypondMetadata`'s index signature.
-const lilypondMetadataSchema = z
-    .object(Object.fromEntries(STANDARD_HEADER_FIELDS.map((field) => [field, z.string().optional()])))
-    .catchall(z.string());
+// Field names must match `LilypondMetadata` in `utils/lilypondMetadata.ts`.
 export const lilypondEntrySchema = z.object({
     source: z.string(),
     alt: z.string(),
     sourceName: z.string().optional(),
     includePaths: z.array(z.string()),
     assetTitle: z.string(),
-    meta: lilypondMetadataSchema,
+    meta: z
+        .object({
+        arranger: z.string().optional(),
+        composer: z.string().optional(),
+        copyright: z.string().optional(),
+        dedication: z.string().optional(),
+        instrument: z.string().optional(),
+        meter: z.string().optional(),
+        opus: z.string().optional(),
+        piece: z.string().optional(),
+        poet: z.string().optional(),
+        subsubtitle: z.string().optional(),
+        subtitle: z.string().optional(),
+        tagline: z.string().optional(),
+        title: z.string().optional(),
+    })
+        .catchall(z.string()),
 });
 function stripLyExtension(entryPath) {
     for (const ext of LY_EXTENSIONS) {
@@ -46,8 +55,7 @@ function posixRelative(from, to) {
 /**
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
-export function lilypondLoader(options) {
-    const { pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, defaults, timeout, autoInstall, } = options;
+export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, defaults, }) {
     const resolved = resolveDefaults(defaults);
     return {
         name: "astro-lilypond-loader",
@@ -57,15 +65,6 @@ export function lilypondLoader(options) {
             const rootDir = fileURLToPath(config.root);
             const baseUrl = resolveBaseUrl(base, config.root);
             const baseDir = fileURLToPath(baseUrl);
-            // Populates the shared render() state, so this collection's entries
-            // can be rendered even when the `lilypond()` integration itself
-            // isn't registered.
-            await resolveAndSetRenderState({
-                autoInstall,
-                defaults,
-                timeout,
-                logger,
-            });
             async function syncEntry(entry) {
                 const filePath = join(baseDir, entry);
                 let source;

package/dist/plugins/index.d.ts

@@ -1,4 +1,3 @@
-export { rehypePlugin } from "./rehype.js";
 export { remarkPlugin } from "./remark.js";
 export { satteriPlugin } from "./satteri.js";
 export type { PluginOptions } from "./types.js";

package/dist/plugins/index.js

@@ -1,3 +1,2 @@
-export { rehypePlugin } from "./rehype.js";
 export { remarkPlugin } from "./remark.js";
 export { satteriPlugin } from "./satteri.js";

package/dist/plugins/satteri.js

@@ -3,9 +3,6 @@ import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, pr
 export function satteriPlugin(options) {
     return {
         name: "astro-lilypond",
-        // Returning an mdast Html node (type: 'html') emits the value verbatim.
-        // Sätteri's { rawHtml } escape hatch applies MDX brace-escaping which
-        // would corrupt SVG content, so we use the plain html node form instead.
         async code(node, ctx) {
             if (!isLilypondLang(node.lang))
                 return undefined;
@@ -34,10 +31,7 @@ export function satteriPlugin(options) {
                     sourceName,
                 }),
             });
-            return {
-                type: "html",
-                value: renderedHtml(pages, alt),
-            };
+            return { rawHtml: renderedHtml(pages, alt) };
         },
     };
 }

package/dist/utils/index.d.ts

@@ -7,8 +7,8 @@ export type { ImageDimensions } from "./imageDimensions.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
-export type { KnownLyHeaderFields, LilypondMetadata, } from "./lilypondMetadata.js";
-export { STANDARD_HEADER_FIELDS, toLilypondMetadata, } from "./lilypondMetadata.js";
+export type { LilypondMetadata } from "./lilypondMetadata.js";
+export { toLilypondMetadata } from "./lilypondMetadata.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export type { LyHeaderFields } from "./parseLyHeader.js";

package/dist/utils/index.js

@@ -6,7 +6,7 @@ export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
-export { STANDARD_HEADER_FIELDS, toLilypondMetadata, } from "./lilypondMetadata.js";
+export { toLilypondMetadata } from "./lilypondMetadata.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";

package/dist/utils/lilypondMetadata.d.ts

@@ -1,9 +1,18 @@
-export declare const STANDARD_HEADER_FIELDS: readonly ["arranger", "composer", "copyright", "dedication", "instrument", "meter", "opus", "piece", "poet", "subsubtitle", "subtitle", "tagline", "title"];
-export type KnownLyHeaderFields = {
-    [K in (typeof STANDARD_HEADER_FIELDS)[number]]?: string;
-};
 /** Header metadata extracted from a score's `\header` block(s). */
-export interface LilypondMetadata extends KnownLyHeaderFields {
+export interface LilypondMetadata {
+    arranger?: string;
+    composer?: string;
+    copyright?: string;
+    dedication?: string;
+    instrument?: string;
+    meter?: string;
+    opus?: string;
+    piece?: string;
+    poet?: string;
+    subsubtitle?: string;
+    subtitle?: string;
+    tagline?: string;
+    title?: string;
     [field: string]: string | undefined;
 }
 /** Tags a bag of parsed `\header` fields (see `parseLyHeaderFields`) as `LilypondMetadata`. */

package/dist/utils/lilypondMetadata.js

@@ -1,18 +1,3 @@
-export const STANDARD_HEADER_FIELDS = [
-    "arranger",
-    "composer",
-    "copyright",
-    "dedication",
-    "instrument",
-    "meter",
-    "opus",
-    "piece",
-    "poet",
-    "subsubtitle",
-    "subtitle",
-    "tagline",
-    "title",
-];
 /** Tags a bag of parsed `\header` fields (see `parseLyHeaderFields`) as `LilypondMetadata`. */
 export function toLilypondMetadata(fields) {
     return fields;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -50,12 +50,12 @@
     "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {
-    "@astrojs/markdown-remark": "^7.2.1",
-    "@astrojs/markdown-satteri": "^0.3.4",
+    "@astrojs/markdown-remark": "^7.2.2",
+    "@astrojs/markdown-satteri": "^0.3.5",
     "@types/mdast": "^4.0.4",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "^4.1.10",
-    "astro": "^7.0.8",
+    "astro": "^7.1.6",
     "satteri": "^0.9.5",
     "typescript": "^7.0.2",
     "unified": "^11.0.5",

package/dist/plugins/rehype.d.ts

@@ -1,4 +0,0 @@
-import type { PluginOptions } from "./types.js";
-export declare function rehypePlugin(options: PluginOptions): (tree: any, file?: {
-    path?: string;
-}) => Promise<void>;

package/dist/plugins/rehype.js

@@ -1,65 +0,0 @@
-import { visit } from "unist-util-visit";
-import { defaultOptions, render } from "../render.js";
-import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
-// Typed loosely so it's assignable to both RehypePlugin and the unified
-// Plugin generic regardless of which @types/hast version the host project pins.
-export function rehypePlugin(options) {
-    return async (tree, file) => {
-        const promises = [];
-        const includePaths = includePathsFor(file?.path);
-        const sourceName = sourceNameFor(file?.path);
-        const title = titleFor(sourceName);
-        visit(tree, "element", (node, index, parent) => {
-            if (node.tagName !== "pre" ||
-                node.children?.length !== 1 ||
-                node.children[0].type !== "element" ||
-                node.children[0].tagName !== "code" ||
-                index === undefined ||
-                !parent)
-                return;
-            const codeNode = node.children[0];
-            const cls = codeNode.properties?.className;
-            if (!Array.isArray(cls))
-                return;
-            const lang = cls
-                .find((c) => c.startsWith("language-"))
-                ?.slice("language-".length);
-            if (!isLilypondLang(lang))
-                return;
-            const raw = codeNode.children
-                .filter((c) => c.type === "text")
-                .map((c) => c.value)
-                .join("");
-            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
-            const source = version ? prependVersion(raw, version) : raw;
-            const format = options.format ?? defaultOptions.format;
-            const alt = altTextForBlock(codeNode.data?.meta, raw);
-            const promise = emitLilypondAsset({
-                title,
-                format,
-                source,
-                resolution,
-                crop: true,
-                sizeScale: cropScale,
-                binaryPath: options.binaryPath,
-                render: () => render(source, {
-                    format,
-                    crop: true,
-                    defaults: options.defaults,
-                    timeout: options.timeout,
-                    binaryPath: options.binaryPath,
-                    includePaths,
-                    sourceName,
-                }),
-            }).then((pages) => {
-                const rawNode = {
-                    type: "raw",
-                    value: renderedHtml(pages, alt),
-                };
-                parent.children[index] = rawNode;
-            });
-            promises.push(promise);
-        });
-        await Promise.all(promises);
-    };
-}