astro-lilypond 0.16.0 → 0.16.1

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/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.1",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",