astro 2.1.3 → 2.1.5

package/dist/assets/vendor/image-size/types/webp.js

@@ -0,0 +1,51 @@
+function calculateExtended(buffer) {
+  return {
+    height: 1 + buffer.readUIntLE(7, 3),
+    width: 1 + buffer.readUIntLE(4, 3)
+  };
+}
+function calculateLossless(buffer) {
+  return {
+    height: 1 + ((buffer[4] & 15) << 10 | buffer[3] << 2 | (buffer[2] & 192) >> 6),
+    width: 1 + ((buffer[2] & 63) << 8 | buffer[1])
+  };
+}
+function calculateLossy(buffer) {
+  return {
+    height: buffer.readInt16LE(8) & 16383,
+    width: buffer.readInt16LE(6) & 16383
+  };
+}
+const WEBP = {
+  validate(buffer) {
+    const riffHeader = "RIFF" === buffer.toString("ascii", 0, 4);
+    const webpHeader = "WEBP" === buffer.toString("ascii", 8, 12);
+    const vp8Header = "VP8" === buffer.toString("ascii", 12, 15);
+    return riffHeader && webpHeader && vp8Header;
+  },
+  calculate(buffer) {
+    const chunkHeader = buffer.toString("ascii", 12, 16);
+    buffer = buffer.slice(20, 30);
+    if (chunkHeader === "VP8X") {
+      const extendedHeader = buffer[0];
+      const validStart = (extendedHeader & 192) === 0;
+      const validEnd = (extendedHeader & 1) === 0;
+      if (validStart && validEnd) {
+        return calculateExtended(buffer);
+      } else {
+        throw new TypeError("Invalid WebP");
+      }
+    }
+    if (chunkHeader === "VP8 " && buffer[0] !== 47) {
+      return calculateLossy(buffer);
+    }
+    const signature = buffer.toString("hex", 3, 6);
+    if (chunkHeader === "VP8L" && signature !== "9d012a") {
+      return calculateLossless(buffer);
+    }
+    throw new TypeError("Invalid WebP");
+  }
+};
+export {
+  WEBP
+};

package/dist/assets/vendor/image-size/types.d.ts

@@ -0,0 +1,19 @@
+export declare const typeHandlers: {
+    bmp: import("./types/interface.js").IImage;
+    cur: import("./types/interface.js").IImage;
+    dds: import("./types/interface.js").IImage;
+    gif: import("./types/interface.js").IImage;
+    icns: import("./types/interface.js").IImage;
+    ico: import("./types/interface.js").IImage;
+    j2c: import("./types/interface.js").IImage;
+    jp2: import("./types/interface.js").IImage;
+    jpg: import("./types/interface.js").IImage;
+    ktx: import("./types/interface.js").IImage;
+    png: import("./types/interface.js").IImage;
+    pnm: import("./types/interface.js").IImage;
+    psd: import("./types/interface.js").IImage;
+    svg: import("./types/interface.js").IImage;
+    tiff: import("./types/interface.js").IImage;
+    webp: import("./types/interface.js").IImage;
+};
+export type imageType = keyof typeof typeHandlers;

package/dist/assets/vendor/image-size/types.js

@@ -0,0 +1,37 @@
+import { BMP } from "./types/bmp.js";
+import { CUR } from "./types/cur.js";
+import { DDS } from "./types/dds.js";
+import { GIF } from "./types/gif.js";
+import { ICNS } from "./types/icns.js";
+import { ICO } from "./types/ico.js";
+import { J2C } from "./types/j2c.js";
+import { JP2 } from "./types/jp2.js";
+import { JPG } from "./types/jpg.js";
+import { KTX } from "./types/ktx.js";
+import { PNG } from "./types/png.js";
+import { PNM } from "./types/pnm.js";
+import { PSD } from "./types/psd.js";
+import { SVG } from "./types/svg.js";
+import { TIFF } from "./types/tiff.js";
+import { WEBP } from "./types/webp.js";
+const typeHandlers = {
+  bmp: BMP,
+  cur: CUR,
+  dds: DDS,
+  gif: GIF,
+  icns: ICNS,
+  ico: ICO,
+  j2c: J2C,
+  jp2: JP2,
+  jpg: JPG,
+  ktx: KTX,
+  png: PNG,
+  pnm: PNM,
+  psd: PSD,
+  svg: SVG,
+  tiff: TIFF,
+  webp: WEBP
+};
+export {
+  typeHandlers
+};

package/dist/assets/vendor/queue/queue.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Since CustomEvent is only supported in nodejs since version 19,
+ * you have to create your own class instead of using CustomEvent
+ * @see https://github.com/nodejs/node/issues/40678
+ * */
+export class QueueEvent extends Event {
+    constructor(name: any, detail: any);
+    detail: any;
+}
+export default class Queue extends EventTarget {
+    constructor(options?: {});
+    concurrency: any;
+    timeout: any;
+    autostart: any;
+    results: any;
+    pending: number;
+    session: number;
+    running: boolean;
+    jobs: any[];
+    timers: any[];
+    _errorHandler(evt: any): void;
+    pop(): any;
+    shift(): any;
+    indexOf(searchElement: any, fromIndex: any): number;
+    lastIndexOf(searchElement: any, fromIndex: any): number;
+    slice(start: any, end: any): Queue;
+    reverse(): Queue;
+    push(...workers: any[]): number;
+    unshift(...workers: any[]): number;
+    splice(start: any, deleteCount: any, ...workers: any[]): Queue;
+    get length(): number;
+    start(callback: any): any;
+    stop(): void;
+    end(error: any): void;
+    clearTimers(): void;
+    _addCallbackToEndEvent(cb: any): void;
+    _createPromiseToEndEvent(): Promise<any>;
+    done(error: any): void;
+}

package/dist/assets/vendor/queue/queue.js

@@ -0,0 +1,187 @@
+const has = Object.prototype.hasOwnProperty;
+class QueueEvent extends Event {
+  constructor(name, detail) {
+    super(name);
+    this.detail = detail;
+  }
+}
+class Queue extends EventTarget {
+  constructor(options = {}) {
+    super();
+    const { concurrency = Infinity, timeout = 0, autostart = false, results = null } = options;
+    this.concurrency = concurrency;
+    this.timeout = timeout;
+    this.autostart = autostart;
+    this.results = results;
+    this.pending = 0;
+    this.session = 0;
+    this.running = false;
+    this.jobs = [];
+    this.timers = [];
+    this.addEventListener("error", this._errorHandler);
+  }
+  _errorHandler(evt) {
+    this.end(evt.detail.error);
+  }
+  pop() {
+    return this.jobs.pop();
+  }
+  shift() {
+    return this.jobs.shift();
+  }
+  indexOf(searchElement, fromIndex) {
+    return this.jobs.indexOf(searchElement, fromIndex);
+  }
+  lastIndexOf(searchElement, fromIndex) {
+    if (fromIndex !== void 0) {
+      return this.jobs.lastIndexOf(searchElement, fromIndex);
+    }
+    return this.jobs.lastIndexOf(searchElement);
+  }
+  slice(start, end) {
+    this.jobs = this.jobs.slice(start, end);
+    return this;
+  }
+  reverse() {
+    this.jobs.reverse();
+    return this;
+  }
+  push(...workers) {
+    const methodResult = this.jobs.push(...workers);
+    if (this.autostart) {
+      this.start();
+    }
+    return methodResult;
+  }
+  unshift(...workers) {
+    const methodResult = this.jobs.unshift(...workers);
+    if (this.autostart) {
+      this.start();
+    }
+    return methodResult;
+  }
+  splice(start, deleteCount, ...workers) {
+    this.jobs.splice(start, deleteCount, ...workers);
+    if (this.autostart) {
+      this.start();
+    }
+    return this;
+  }
+  get length() {
+    return this.pending + this.jobs.length;
+  }
+  start(callback) {
+    let awaiter;
+    if (callback) {
+      this._addCallbackToEndEvent(callback);
+    } else {
+      awaiter = this._createPromiseToEndEvent();
+    }
+    this.running = true;
+    if (this.pending >= this.concurrency) {
+      return;
+    }
+    if (this.jobs.length === 0) {
+      if (this.pending === 0) {
+        this.done();
+      }
+      return;
+    }
+    const job = this.jobs.shift();
+    const session = this.session;
+    const timeout = job !== void 0 && has.call(job, "timeout") ? job.timeout : this.timeout;
+    let once = true;
+    let timeoutId = null;
+    let didTimeout = false;
+    let resultIndex = null;
+    const next = (error, ...result) => {
+      if (once && this.session === session) {
+        once = false;
+        this.pending--;
+        if (timeoutId !== null) {
+          this.timers = this.timers.filter((tID) => tID !== timeoutId);
+          clearTimeout(timeoutId);
+        }
+        if (error) {
+          this.dispatchEvent(new QueueEvent("error", { error, job }));
+        } else if (!didTimeout) {
+          if (resultIndex !== null && this.results !== null) {
+            this.results[resultIndex] = [...result];
+          }
+          this.dispatchEvent(new QueueEvent("success", { result: [...result], job }));
+        }
+        if (this.session === session) {
+          if (this.pending === 0 && this.jobs.length === 0) {
+            this.done();
+          } else if (this.running) {
+            this.start();
+          }
+        }
+      }
+    };
+    if (timeout) {
+      timeoutId = setTimeout(() => {
+        didTimeout = true;
+        this.dispatchEvent(new QueueEvent("timeout", { next, job }));
+        next();
+      }, timeout);
+      this.timers.push(timeoutId);
+    }
+    if (this.results != null) {
+      resultIndex = this.results.length;
+      this.results[resultIndex] = null;
+    }
+    this.pending++;
+    this.dispatchEvent(new QueueEvent("start", { job }));
+    const promise = job(next);
+    if (promise !== void 0 && typeof promise.then === "function") {
+      promise.then(function(result) {
+        return next(void 0, result);
+      }).catch(function(err) {
+        return next(err || true);
+      });
+    }
+    if (this.running && this.jobs.length > 0) {
+      return this.start();
+    }
+    return awaiter;
+  }
+  stop() {
+    this.running = false;
+  }
+  end(error) {
+    this.clearTimers();
+    this.jobs.length = 0;
+    this.pending = 0;
+    this.done(error);
+  }
+  clearTimers() {
+    this.timers.forEach((timer) => {
+      clearTimeout(timer);
+    });
+    this.timers = [];
+  }
+  _addCallbackToEndEvent(cb) {
+    const onend = (evt) => {
+      this.removeEventListener("end", onend);
+      cb(evt.detail.error, this.results);
+    };
+    this.addEventListener("end", onend);
+  }
+  _createPromiseToEndEvent() {
+    return new Promise((resolve) => {
+      this._addCallbackToEndEvent((error, results) => {
+        resolve({ error, results });
+      });
+    });
+  }
+  done(error) {
+    this.session++;
+    this.running = false;
+    this.dispatchEvent(new QueueEvent("end", { error }));
+  }
+}
+export {
+  QueueEvent,
+  Queue as default
+};

package/dist/assets/vite-plugin-assets.js

@@ -43,6 +43,7 @@ function assets({
     );
   }
   return [
+    // Expose the components and different utilities from `astro:assets` and handle serving images from `/_image` in dev
     {
       name: "astro:assets",
       config() {
@@ -73,6 +74,7 @@ function assets({
 				`;
         }
       },
+      // Handle serving images during development
       configureServer(server) {
         server.middlewares.use(async (req, res, next) => {
           var _a2;
@@ -150,6 +152,7 @@ function assets({
         const dir = settings.config.output === "server" ? settings.config.build.server : settings.config.outDir;
         await copyWasmFiles(new URL("./chunks", dir));
       },
+      // In build, rewrite paths to ESM imported images in code to their final location
       async renderChunk(code) {
         const assetUrlRE = /__ASTRO_ASSET_IMAGE__([a-z\d]{8})__(?:_(.*?)__)?/g;
         let match;
@@ -171,6 +174,7 @@ function assets({
         }
       }
     },
+    // Return a more advanced shape for images imported in ESM
     {
       name: "astro:assets:esm",
       enforce: "pre",

package/dist/cli/check/index.js

@@ -1,4 +1,7 @@
-import { AstroCheck, DiagnosticSeverity } from "@astrojs/language-server";
+import {
+  AstroCheck,
+  DiagnosticSeverity
+} from "@astrojs/language-server";
 import glob from "fast-glob";
 import * as fs from "fs";
 import { bold, dim, red, yellow } from "kleur/colors";
@@ -22,7 +25,10 @@ async function check(settings, { logging, flags }) {
       commandName: "astro check",
       usage: "[...flags]",
       tables: {
-        Flags: [["--help (-h)", "See all available flags."]]
+        Flags: [
+          ["--watch", "Watch Astro files for changes and re-run checks."],
+          ["--help (-h)", "See all available flags."]
+        ]
       },
       description: `Runs diagnostics against your project and reports errors to the console.`
     });
@@ -78,18 +84,30 @@ class AstroChecker {
     this.#fs = fileSystem;
     this.#filesCount = 0;
   }
+  /**
+   * Check all `.astro` files once and then finishes the operation.
+   */
   async check() {
     return await this.#checkAllFiles(true);
   }
+  /**
+   * Check all `.astro` files and then start watching for changes.
+   */
   async watch() {
     await this.#checkAllFiles(true);
     await this.#watch();
     return 2 /* Listen */;
   }
+  /**
+   * Stops the watch. It terminates the inner server.
+   */
   async stop() {
     var _a;
     await ((_a = this.#watcher) == null ? void 0 : _a.close());
   }
+  /**
+   * Whether the checker should run in watch mode
+   */
   get isWatchMode() {
     return this.#shouldWatch;
   }
@@ -100,6 +118,14 @@ class AstroChecker {
       this.#diagnosticsChecker
     );
   }
+  /**
+   * Lint all `.astro` files, and report the result in console. Operations executed, in order:
+   * 1. Compile content collections.
+   * 2. Optionally, traverse the file system for `.astro` files and saves their paths.
+   * 3. Get diagnostics for said files and print the result in console.
+   *
+   * @param openDocuments Whether the operation should open all `.astro` files
+   */
   async #checkAllFiles(openDocuments) {
     const processExit = await this.#syncCli(this.#settings, {
       logging: this.#logging,
@@ -123,6 +149,9 @@ class AstroChecker {
     clearTimeout(this.#updateDiagnostics);
     this.#updateDiagnostics = setTimeout(async () => await this.#checkAllFiles(false), 500);
   }
+  /**
+   * This function is responsible to attach events to the server watcher
+   */
   async #watch() {
     const { default: chokidar } = await import("chokidar");
     this.#watcher = chokidar.watch(
@@ -147,6 +176,10 @@ class AstroChecker {
       this.#checkForDiagnostics();
     });
   }
+  /**
+   * Add a document to the diagnostics checker
+   * @param filePath Path to the file
+   */
   #addDocument(filePath) {
     const text = fs.readFileSync(filePath, "utf-8");
     this.#diagnosticsChecker.upsertDocument({
@@ -154,6 +187,11 @@ class AstroChecker {
       text
     });
   }
+  /**
+   * Logs the result of the various diagnostics
+   *
+   * @param result Result emitted by AstroChecker.#breakDownDiagnostics
+   */
   #logDiagnosticsSeverity(result) {
     info(
       this.#logging,
@@ -168,6 +206,9 @@ class AstroChecker {
 ${dim("-")} `)
     );
   }
+  /**
+   * It loops through all diagnostics and break down diagnostics that are errors, warnings or hints.
+   */
   #breakDownDiagnostics(diagnostics) {
     let result = {
       errors: 0,

package/dist/cli/check/print.d.ts

@@ -1,2 +1,2 @@
-import { Diagnostic } from '@astrojs/language-server';
+import { type Diagnostic } from '@astrojs/language-server';
 export declare function printDiagnostic(filePath: string, text: string, diag: Diagnostic): string;

package/dist/content/error-map.js

@@ -25,7 +25,10 @@ const errorMap = (baseError, ctx) => {
     return {
       message: messages.concat(
         [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
-          ([key, error]) => key === baseErrorPath ? `> ${getTypeOrLiteralMsg(error)}` : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+          ([key, error]) => key === baseErrorPath ? (
+            // Avoid printing the key again if it's a base error
+            `> ${getTypeOrLiteralMsg(error)}`
+          ) : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
         )
       ).join("\n")
     };

package/dist/content/server-listeners.d.ts

@@ -2,7 +2,7 @@
 import type fsMod from 'node:fs';
 import type { ViteDevServer } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
-import { LogOptions } from '../core/logger/core.js';
+import { type LogOptions } from '../core/logger/core.js';
 interface ContentServerListenerParams {
     fs: typeof fsMod;
     logging: LogOptions;

package/dist/content/types-generator.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import type fsMod from 'node:fs';
-import { ViteDevServer } from 'vite';
+import { type ViteDevServer } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
-import { LogOptions } from '../core/logger/core.js';
-import { ContentObservable } from './utils.js';
+import { type LogOptions } from '../core/logger/core.js';
+import { type ContentObservable } from './utils.js';
 type ChokidarEvent = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
 type RawContentEvent = {
     name: ChokidarEvent;

package/dist/content/types-generator.js

@@ -48,6 +48,7 @@ async function createContentTypesGenerator({
       }
     });
     const entries = globResult.map((e) => new URL(e, contentPaths.contentDir)).filter(
+      // Config loading handled first. Avoid running twice.
       (e) => !e.href.startsWith(contentPaths.config.url.href)
     );
     for (const entry of entries) {
@@ -107,6 +108,7 @@ async function createContentTypesGenerator({
       const entryInfo2 = getEntryInfo({
         entry: event.entry,
         contentDir: contentPaths.contentDir,
+        // Skip invalid file check. We already know it’s invalid.
         allowFilesOutsideCollection: true
       });
       return {
@@ -174,6 +176,7 @@ async function createContentTypesGenerator({
     debounceTimeout = setTimeout(
       async () => runEvents(opts),
       50
+      /* debounce to batch chokidar events */
     );
   }
   async function runEvents(opts) {

package/dist/content/utils.d.ts

@@ -2,7 +2,7 @@
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
 import type { EmitFile } from 'rollup';
-import { ViteDevServer } from 'vite';
+import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings } from '../@types/astro.js';
 export declare const collectionConfigParser: z.ZodObject<{
@@ -36,7 +36,7 @@ export declare const contentConfigParser: z.ZodObject<{
 export type CollectionConfig = z.infer<typeof collectionConfigParser>;
 export type ContentConfig = z.infer<typeof contentConfigParser>;
 type EntryInternal = {
-    rawData: string;
+    rawData: string | undefined;
     filePath: string;
 };
 export type EntryInfo = {

package/dist/content/utils.js

@@ -151,6 +151,8 @@ function hasUnderscoreBelowContentDirectoryPath(fileUrl, contentDir) {
   return false;
 }
 function getFrontmatterErrorLine(rawFrontmatter, frontmatterKey) {
+  if (!rawFrontmatter)
+    return 0;
   const indexOfFrontmatterKey = rawFrontmatter.indexOf(`
 ${frontmatterKey}`);
   if (indexOfFrontmatterKey === -1)

package/dist/content/vite-plugin-content-assets.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
-import { BuildInternals } from '../core/build/internal.js';
+import { type BuildInternals } from '../core/build/internal.js';
 import type { AstroBuildPlugin } from '../core/build/plugin.js';
 import type { StaticBuildOptions } from '../core/build/types';
 export declare function astroContentAssetPropagationPlugin({ mode, settings, }: {

package/dist/content/vite-plugin-content-imports.d.ts

@@ -5,4 +5,4 @@ import type { AstroSettings } from '../@types/astro.js';
 export declare function astroContentImportPlugin({ fs, settings, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
-}): Plugin;
+}): Plugin[];