astro 4.13.3 → 4.14.0

package/dist/content/loaders/glob.js

@@ -0,0 +1,218 @@
+import { promises as fs } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import fastGlob from "fast-glob";
+import { bold, green } from "kleur/colors";
+import micromatch from "micromatch";
+import pLimit from "p-limit";
+import { getContentEntryIdAndSlug, getEntryConfigByExtMap, posixRelative } from "../utils.js";
+function generateIdDefault({ entry, base, data }) {
+  if (data.slug) {
+    return data.slug;
+  }
+  const entryURL = new URL(entry, base);
+  const { slug } = getContentEntryIdAndSlug({
+    entry: entryURL,
+    contentDir: base,
+    collection: ""
+  });
+  return slug;
+}
+function glob(globOptions) {
+  if (globOptions.pattern.startsWith("../")) {
+    throw new Error(
+      "Glob patterns cannot start with `../`. Set the `base` option to a parent directory instead."
+    );
+  }
+  if (globOptions.pattern.startsWith("/")) {
+    throw new Error(
+      "Glob patterns cannot start with `/`. Set the `base` option to a parent directory or use a relative path instead."
+    );
+  }
+  const generateId = globOptions?.generateId ?? generateIdDefault;
+  const fileToIdMap = /* @__PURE__ */ new Map();
+  return {
+    name: "glob-loader",
+    load: async ({ settings, logger, watcher, parseData, store, generateDigest }) => {
+      const renderFunctionByContentType = /* @__PURE__ */ new WeakMap();
+      const untouchedEntries = new Set(store.keys());
+      async function syncData(entry, base, entryType) {
+        if (!entryType) {
+          logger.warn(`No entry type found for ${entry}`);
+          return;
+        }
+        const fileUrl = new URL(entry, base);
+        const contents = await fs.readFile(fileUrl, "utf-8").catch((err) => {
+          logger.error(`Error reading ${entry}: ${err.message}`);
+          return;
+        });
+        if (!contents) {
+          logger.warn(`No contents found for ${entry}`);
+          return;
+        }
+        const { body, data } = await entryType.getEntryInfo({
+          contents,
+          fileUrl
+        });
+        const id = generateId({ entry, base, data });
+        untouchedEntries.delete(id);
+        const existingEntry = store.get(id);
+        const digest = generateDigest(contents);
+        if (existingEntry && existingEntry.digest === digest && existingEntry.filePath) {
+          if (existingEntry.deferredRender) {
+            store.addModuleImport(existingEntry.filePath);
+          }
+          if (existingEntry.rendered?.metadata?.imagePaths?.length) {
+            store.addAssetImports(
+              existingEntry.rendered.metadata.imagePaths,
+              existingEntry.filePath
+            );
+          }
+          await parseData(existingEntry);
+          return;
+        }
+        const filePath = fileURLToPath(fileUrl);
+        const relativePath = posixRelative(fileURLToPath(settings.config.root), filePath);
+        const parsedData = await parseData({
+          id,
+          data,
+          filePath
+        });
+        if (entryType.getRenderFunction) {
+          let render = renderFunctionByContentType.get(entryType);
+          if (!render) {
+            render = await entryType.getRenderFunction(settings);
+            renderFunctionByContentType.set(entryType, render);
+          }
+          let rendered = void 0;
+          try {
+            rendered = await render?.({
+              id,
+              data: parsedData,
+              body,
+              filePath,
+              digest
+            });
+          } catch (error) {
+            logger.error(`Error rendering ${entry}: ${error.message}`);
+          }
+          store.set({
+            id,
+            data: parsedData,
+            body,
+            filePath: relativePath,
+            digest,
+            rendered
+          });
+          if (rendered?.metadata?.imagePaths?.length) {
+            store.addAssetImports(rendered.metadata.imagePaths, relativePath);
+          }
+        } else if ("contentModuleTypes" in entryType) {
+          store.set({
+            id,
+            data: parsedData,
+            body,
+            filePath: relativePath,
+            digest,
+            deferredRender: true
+          });
+        } else {
+          store.set({ id, data: parsedData, body, filePath: relativePath, digest });
+        }
+        fileToIdMap.set(filePath, id);
+      }
+      const entryConfigByExt = getEntryConfigByExtMap([
+        ...settings.contentEntryTypes,
+        ...settings.dataEntryTypes
+      ]);
+      const baseDir = globOptions.base ? new URL(globOptions.base, settings.config.root) : settings.config.root;
+      if (!baseDir.pathname.endsWith("/")) {
+        baseDir.pathname = `${baseDir.pathname}/`;
+      }
+      const files = await fastGlob(globOptions.pattern, {
+        cwd: fileURLToPath(baseDir)
+      });
+      function configForFile(file) {
+        const ext = file.split(".").at(-1);
+        if (!ext) {
+          logger.warn(`No extension found for ${file}`);
+          return;
+        }
+        return entryConfigByExt.get(`.${ext}`);
+      }
+      const limit = pLimit(10);
+      const skippedFiles = [];
+      const contentDir = new URL("content/", settings.config.srcDir);
+      function isInContentDir(file) {
+        const fileUrl = new URL(file, baseDir);
+        return fileUrl.href.startsWith(contentDir.href);
+      }
+      const configFiles = new Set(
+        ["config.js", "config.ts", "config.mjs"].map((file) => new URL(file, contentDir).href)
+      );
+      function isConfigFile(file) {
+        const fileUrl = new URL(file, baseDir);
+        return configFiles.has(fileUrl.href);
+      }
+      await Promise.all(
+        files.map((entry) => {
+          if (isConfigFile(entry)) {
+            return;
+          }
+          if (isInContentDir(entry)) {
+            skippedFiles.push(entry);
+            return;
+          }
+          return limit(async () => {
+            const entryType = configForFile(entry);
+            await syncData(entry, baseDir, entryType);
+          });
+        })
+      );
+      const skipCount = skippedFiles.length;
+      if (skipCount > 0) {
+        logger.warn(`The glob() loader cannot be used for files in ${bold("src/content")}.`);
+        if (skipCount > 10) {
+          logger.warn(
+            `Skipped ${green(skippedFiles.length)} files that matched ${green(globOptions.pattern)}.`
+          );
+        } else {
+          logger.warn(`Skipped the following files that matched ${green(globOptions.pattern)}:`);
+          skippedFiles.forEach((file) => logger.warn(`\u2022 ${green(file)}`));
+        }
+      }
+      untouchedEntries.forEach((id) => store.delete(id));
+      if (!watcher) {
+        return;
+      }
+      const matcher = micromatch.makeRe(globOptions.pattern);
+      const matchesGlob = (entry) => !entry.startsWith("../") && matcher.test(entry);
+      const basePath = fileURLToPath(baseDir);
+      async function onChange(changedPath) {
+        const entry = posixRelative(basePath, changedPath);
+        if (!matchesGlob(entry)) {
+          return;
+        }
+        const entryType = configForFile(changedPath);
+        const baseUrl = pathToFileURL(basePath);
+        await syncData(entry, baseUrl, entryType);
+        logger.info(`Reloaded data from ${green(entry)}`);
+      }
+      watcher.on("change", onChange);
+      watcher.on("add", onChange);
+      watcher.on("unlink", async (deletedPath) => {
+        const entry = posixRelative(basePath, deletedPath);
+        if (!matchesGlob(entry)) {
+          return;
+        }
+        const id = fileToIdMap.get(deletedPath);
+        if (id) {
+          store.delete(id);
+          fileToIdMap.delete(deletedPath);
+        }
+      });
+    }
+  };
+}
+export {
+  glob
+};

package/dist/content/loaders/index.d.ts

@@ -0,0 +1,3 @@
+export { file } from './file.js';
+export { glob } from './glob.js';
+export * from './types.js';

package/dist/content/loaders/index.js

@@ -0,0 +1,7 @@
+import { file } from "./file.js";
+import { glob } from "./glob.js";
+export * from "./types.js";
+export {
+  file,
+  glob
+};

package/dist/content/loaders/types.d.ts

@@ -0,0 +1,36 @@
+import type { FSWatcher } from 'vite';
+import type { ZodSchema } from 'zod';
+import type { AstroIntegrationLogger, AstroSettings } from '../../@types/astro.js';
+import type { MetaStore, ScopedDataStore } from '../data-store.js';
+export interface ParseDataOptions<TData extends Record<string, unknown>> {
+    /** The ID of the entry. Unique per collection */
+    id: string;
+    /** The raw, unvalidated data of the entry */
+    data: TData;
+    /** An optional file path, where the entry represents a local file. */
+    filePath?: string;
+}
+export interface LoaderContext {
+    /** The unique name of the collection */
+    collection: string;
+    /** A database abstraction to store the actual data */
+    store: ScopedDataStore;
+    /**  A simple KV store, designed for things like sync tokens */
+    meta: MetaStore;
+    logger: AstroIntegrationLogger;
+    settings: AstroSettings;
+    /** Validates and parses the data according to the collection schema */
+    parseData<TData extends Record<string, unknown>>(props: ParseDataOptions<TData>): Promise<TData>;
+    /** Generates a non-cryptographic content digest. This can be used to check if the data has changed */
+    generateDigest(data: Record<string, unknown> | string): string;
+    /** When running in dev, this is a filesystem watcher that can be used to trigger updates */
+    watcher?: FSWatcher;
+}
+export interface Loader {
+    /** Unique name of the loader, e.g. the npm package name */
+    name: string;
+    /** Do the actual loading of the data */
+    load: (context: LoaderContext) => Promise<void>;
+    /** Optionally, define the schema of the data. Will be overridden by user-defined schema */
+    schema?: ZodSchema | Promise<ZodSchema> | (() => ZodSchema | Promise<ZodSchema>);
+}

package/dist/content/runtime.d.ts

@@ -1,5 +1,7 @@
 import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import { z } from 'zod';
 import { type AstroComponentFactory } from '../runtime/server/index.js';
+import { type DataEntry } from './data-store.js';
 import type { ContentLookupMap } from './utils.js';
 type LazyImport = () => Promise<any>;
 type GlobResult = Record<string, LazyImport>;
@@ -16,9 +18,10 @@ export declare function createGetCollection({ contentCollectionToEntryMap, dataC
     getRenderEntryImport: GetEntryImport;
     cacheEntriesByCollection: Map<string, any[]>;
 }): (collection: string, filter?: (entry: any) => unknown) => Promise<any[]>;
-export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, }: {
+export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, collectionNames, }: {
     getEntryImport: GetEntryImport;
     getRenderEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
 }): (collection: string, slug: string) => Promise<{
     id: any;
     slug: any;
@@ -27,13 +30,14 @@ export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImp
     data: any;
     render(): Promise<RenderResult>;
 } | undefined>;
-export declare function createGetDataEntryById({ getEntryImport }: {
+export declare function createGetDataEntryById({ getEntryImport, collectionNames, }: {
     getEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
 }): (collection: string, id: string) => Promise<{
     id: any;
     collection: any;
     data: any;
-}>;
+} | undefined>;
 type ContentEntryResult = {
     id: string;
     slug: string;
@@ -54,9 +58,10 @@ type EntryLookupObject = {
     collection: string;
     slug: string;
 };
-export declare function createGetEntry({ getEntryImport, getRenderEntryImport, }: {
+export declare function createGetEntry({ getEntryImport, getRenderEntryImport, collectionNames, }: {
     getEntryImport: GetEntryImport;
     getRenderEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
 }): (collectionOrLookupObject: string | EntryLookupObject, _lookupId?: string) => Promise<ContentEntryResult | DataEntryResult | undefined>;
 export declare function createGetEntries(getEntry: ReturnType<typeof createGetEntry>): (entries: {
     collection: string;
@@ -70,15 +75,48 @@ type RenderResult = {
     headings: MarkdownHeading[];
     remarkPluginFrontmatter: Record<string, any>;
 };
+export declare function renderEntry(entry: DataEntry | {
+    render: () => Promise<{
+        Content: AstroComponentFactory;
+    }>;
+}): Promise<{
+    Content: AstroComponentFactory;
+} | {
+    Content: any;
+    headings: any;
+    remarkPluginFrontmatter: any;
+}>;
 export declare function createReference({ lookupMap }: {
     lookupMap: ContentLookupMap;
-}): (collection: string) => import("zod").ZodEffects<import("zod").ZodString, {
+}): (collection: string) => z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    collection: string;
+}, {
+    id: string;
+    collection: string;
+}>, z.ZodObject<{
+    slug: z.ZodString;
+    collection: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
     slug: string;
+}, {
+    collection: string;
+    slug: string;
+}>]>, {
+    id: string;
     collection: string;
-    id?: undefined;
 } | {
+    slug: string;
+    collection: string;
+} | undefined, string | {
     id: string;
     collection: string;
-    slug?: undefined;
-} | undefined, string>;
+} | {
+    collection: string;
+    slug: string;
+}>;
 export {};