astro 4.13.4 → 4.14.1

package/dist/cli/index.js

@@ -1,5 +1,5 @@
+import { parseArgs } from "node:util";
 import * as colors from "kleur/colors";
-import yargs from "yargs-parser";
 import { ASTRO_VERSION } from "../core/constants.js";
 async function printAstroHelp() {
   const { printHelp } = await import("../core/messages.js");
@@ -43,9 +43,9 @@ function printVersion() {
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${ASTRO_VERSION}`)}`);
 }
-function resolveCommand(flags) {
-  const cmd = flags._[2];
-  if (flags.version) return "version";
+function resolveCommand(args) {
+  const cmd = args.positionals[2];
+  if (args.values.version) return "version";
   const supportedCommands = /* @__PURE__ */ new Set([
     "add",
     "sync",
@@ -68,7 +68,8 @@ function resolveCommand(flags) {
   }
   return "help";
 }
-async function runCommand(cmd, flags) {
+async function runCommand(cmd, args) {
+  const flags = args.values;
   switch (cmd) {
     case "help":
       await printAstroHelp();
@@ -88,7 +89,7 @@ async function runCommand(cmd, flags) {
     }
     case "telemetry": {
       const { update } = await import("./telemetry/index.js");
-      const subcommand = flags._[3]?.toString();
+      const subcommand = args.positionals[3];
       await update(subcommand, { flags });
       return;
     }
@@ -99,7 +100,7 @@ async function runCommand(cmd, flags) {
     }
     case "preferences": {
       const { preferences } = await import("./preferences/index.js");
-      const [subcommand, key, value] = flags._.slice(3).map((v) => v.toString());
+      const [subcommand, key, value] = args.positionals.slice(3);
       const exitCode = await preferences(subcommand, key, value, { flags });
       return process.exit(exitCode);
     }
@@ -113,7 +114,7 @@ async function runCommand(cmd, flags) {
   switch (cmd) {
     case "add": {
       const { add } = await import("./add/index.js");
-      const packages = flags._.slice(3);
+      const packages = args.positionals.slice(3);
       await add(packages, { flags });
       return;
     }
@@ -123,7 +124,7 @@ async function runCommand(cmd, flags) {
     case "link":
     case "init": {
       const { db } = await import("./db/index.js");
-      await db({ flags });
+      await db({ positionals: args.positionals, flags });
       return;
     }
     case "dev": {
@@ -161,11 +162,23 @@ async function runCommand(cmd, flags) {
   }
   throw new Error(`Error running ${cmd} -- no command found.`);
 }
-async function cli(args) {
-  const flags = yargs(args, { boolean: ["global"], alias: { g: "global" } });
-  const cmd = resolveCommand(flags);
+async function cli(argv) {
+  const args = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      global: { type: "boolean", short: "g" },
+      host: { type: "string" },
+      // Can be boolean too, which is covered by `strict: false`
+      open: { type: "string" }
+      // Can be boolean too, which is covered by `strict: false`
+      // TODO: Add more flags here
+    }
+  });
+  const cmd = resolveCommand(args);
   try {
-    await runCommand(cmd, flags);
+    await runCommand(cmd, args);
   } catch (err) {
     const { throwAndExit } = await import("./throw-and-exit.js");
     await throwAndExit(cmd, err);

package/dist/cli/info/index.d.ts

@@ -1,7 +1,7 @@
-import type yargs from 'yargs-parser';
 import type { AstroConfig, AstroUserConfig } from '../../@types/astro.js';
+import { type Flags } from '../flags.js';
 interface InfoOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function getInfoOutput({ userConfig, print, }: {
     userConfig: AstroUserConfig | AstroConfig;

package/dist/cli/preferences/index.d.ts

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface PreferencesOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 declare const PREFERENCES_SUBCOMMANDS: readonly ["get", "set", "enable", "disable", "delete", "reset", "list"];
 export type Subcommand = (typeof PREFERENCES_SUBCOMMANDS)[number];

package/dist/cli/preferences/index.js

@@ -55,7 +55,7 @@ async function preferences(subcommand, key, value, { flags }) {
   const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const opts = {
     location: flags.global ? "global" : void 0,
-    json: flags.json
+    json: !!flags.json
   };
   if (subcommand === "list") {
     return listPreferences(settings, opts);

package/dist/cli/preview/index.d.ts

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface PreviewOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function preview({ flags }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
 export {};

package/dist/cli/sync/index.d.ts

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface SyncOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function sync({ flags }: SyncOptions): Promise<0 | 1>;
 export {};

package/dist/cli/sync/index.js

@@ -7,14 +7,17 @@ async function sync({ flags }) {
       commandName: "astro sync",
       usage: "[...flags]",
       tables: {
-        Flags: [["--help (-h)", "See all available flags."]]
+        Flags: [
+          ["--force", "Clear the content layer cache, forcing a full rebuild."],
+          ["--help (-h)", "See all available flags."]
+        ]
       },
       description: `Generates TypeScript types for all Astro modules.`
     });
     return 0;
   }
   try {
-    await _sync({ inlineConfig: flagsToAstroInlineConfig(flags), telemetry: true });
+    await _sync(flagsToAstroInlineConfig(flags), { telemetry: true });
     return 0;
   } catch (_) {
     return 1;

package/dist/cli/telemetry/index.d.ts

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface TelemetryOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function notify(): Promise<void>;
 export declare function update(subcommand: string, { flags }: TelemetryOptions): Promise<void>;

package/dist/content/consts.d.ts

@@ -2,10 +2,24 @@ export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
 export declare const CONTENT_FLAG = "astroContentCollectionEntry";
 export declare const DATA_FLAG = "astroDataCollectionEntry";
+export declare const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+export declare const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
 export declare const VIRTUAL_MODULE_ID = "astro:content";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+export declare const RESOLVED_DATA_STORE_VIRTUAL_ID: string;
+export declare const MODULES_MJS_ID = "astro:content-module-imports";
+export declare const MODULES_MJS_VIRTUAL_ID: string;
+export declare const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+export declare const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+export declare const ASSET_IMPORTS_RESOLVED_STUB_ID: string;
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
-export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets"];
-export declare const CONTENT_TYPES_FILE = "types.d.ts";
+export declare const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
+export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets", "astroContentImageFlag", "astroContentModuleFlag"];
+export declare const CONTENT_TYPES_FILE = "astro/content.d.ts";
+export declare const DATA_STORE_FILE = "data-store.json";
+export declare const ASSET_IMPORTS_FILE = "assets.mjs";
+export declare const MODULES_IMPORTS_FILE = "modules.mjs";
+export declare const CONTENT_LAYER_TYPE = "content_layer";

package/dist/content/consts.js

@@ -2,26 +2,56 @@ const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 const CONTENT_RENDER_FLAG = "astroRenderContent";
 const CONTENT_FLAG = "astroContentCollectionEntry";
 const DATA_FLAG = "astroDataCollectionEntry";
+const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
 const VIRTUAL_MODULE_ID = "astro:content";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+const RESOLVED_DATA_STORE_VIRTUAL_ID = "\0" + DATA_STORE_VIRTUAL_ID;
+const MODULES_MJS_ID = "astro:content-module-imports";
+const MODULES_MJS_VIRTUAL_ID = "\0" + MODULES_MJS_ID;
+const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+const ASSET_IMPORTS_RESOLVED_STUB_ID = "\0" + ASSET_IMPORTS_VIRTUAL_ID;
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
 const CONTENT_FLAGS = [
   CONTENT_FLAG,
   CONTENT_RENDER_FLAG,
   DATA_FLAG,
-  PROPAGATED_ASSET_FLAG
+  PROPAGATED_ASSET_FLAG,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_MODULE_FLAG
 ];
-const CONTENT_TYPES_FILE = "types.d.ts";
+const CONTENT_TYPES_FILE = "astro/content.d.ts";
+const DATA_STORE_FILE = "data-store.json";
+const ASSET_IMPORTS_FILE = "assets.mjs";
+const MODULES_IMPORTS_FILE = "modules.mjs";
+const CONTENT_LAYER_TYPE = "content_layer";
 export {
+  ASSET_IMPORTS_FILE,
+  ASSET_IMPORTS_RESOLVED_STUB_ID,
+  ASSET_IMPORTS_VIRTUAL_ID,
   CONTENT_FLAG,
   CONTENT_FLAGS,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_LAYER_TYPE,
+  CONTENT_MODULE_FLAG,
   CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
+  DATA_STORE_FILE,
+  DATA_STORE_VIRTUAL_ID,
+  DEFERRED_MODULE,
+  IMAGE_IMPORT_PREFIX,
   LINKS_PLACEHOLDER,
+  MODULES_IMPORTS_FILE,
+  MODULES_MJS_ID,
+  MODULES_MJS_VIRTUAL_ID,
   PROPAGATED_ASSET_FLAG,
+  RESOLVED_DATA_STORE_VIRTUAL_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER,

package/dist/content/content-layer.d.ts

@@ -0,0 +1,40 @@
+import type { FSWatcher } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+import type { LoaderContext } from './loaders/types.js';
+import type { MutableDataStore } from './mutable-data-store.js';
+export interface ContentLayerOptions {
+    store: MutableDataStore;
+    settings: AstroSettings;
+    logger: Logger;
+    watcher?: FSWatcher;
+}
+export declare class ContentLayer {
+    #private;
+    constructor({ settings, logger, store, watcher }: ContentLayerOptions);
+    /**
+     * Whether the content layer is currently loading content
+     */
+    get loading(): boolean;
+    /**
+     * Watch for changes to the content config and trigger a sync when it changes.
+     */
+    watchContentConfig(): void;
+    unwatchContentConfig(): void;
+    /**
+     * Run the `load()` method of each collection's loader, which will load the data and save it in the data store.
+     * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+     * perform an incremental update. After the data is loaded, the data store is written to disk.
+     */
+    sync(): Promise<void>;
+    regenerateCollectionFileManifest(): Promise<void>;
+}
+export declare function simpleLoader<TData extends {
+    id: string;
+}>(handler: () => Array<TData> | Promise<Array<TData>>, context: LoaderContext): Promise<void>;
+export declare const globalContentLayer: {
+    initialized: () => boolean;
+    init: (options: ContentLayerOptions) => ContentLayer;
+    get: () => ContentLayer;
+    dispose: () => void;
+};

package/dist/content/content-layer.js

@@ -0,0 +1,253 @@
+import { promises as fs, existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import xxhash from "xxhash-wasm";
+import { AstroUserError } from "../core/errors/errors.js";
+import {
+  ASSET_IMPORTS_FILE,
+  CONTENT_LAYER_TYPE,
+  DATA_STORE_FILE,
+  MODULES_IMPORTS_FILE
+} from "./consts.js";
+import { getEntryDataAndImages, globalContentConfigObserver, posixRelative } from "./utils.js";
+class ContentLayer {
+  #logger;
+  #store;
+  #settings;
+  #watcher;
+  #lastConfigDigest;
+  #unsubscribe;
+  #generateDigest;
+  #loading = false;
+  constructor({ settings, logger, store, watcher }) {
+    watcher?.setMaxListeners(50);
+    this.#logger = logger;
+    this.#store = store;
+    this.#settings = settings;
+    this.#watcher = watcher;
+  }
+  /**
+   * Whether the content layer is currently loading content
+   */
+  get loading() {
+    return this.#loading;
+  }
+  /**
+   * Watch for changes to the content config and trigger a sync when it changes.
+   */
+  watchContentConfig() {
+    this.#unsubscribe?.();
+    this.#unsubscribe = globalContentConfigObserver.subscribe(async (ctx) => {
+      if (!this.#loading && ctx.status === "loaded" && ctx.config.digest !== this.#lastConfigDigest) {
+        this.sync();
+      }
+    });
+  }
+  unwatchContentConfig() {
+    this.#unsubscribe?.();
+  }
+  /**
+   * Run the `load()` method of each collection's loader, which will load the data and save it in the data store.
+   * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+   * perform an incremental update. After the data is loaded, the data store is written to disk.
+   */
+  async sync() {
+    if (this.#loading) {
+      return;
+    }
+    this.#loading = true;
+    try {
+      await this.#doSync();
+    } finally {
+      this.#loading = false;
+    }
+  }
+  async #getGenerateDigest() {
+    if (this.#generateDigest) {
+      return this.#generateDigest;
+    }
+    const { h64ToString } = await xxhash();
+    this.#generateDigest = (data) => {
+      const dataString = typeof data === "string" ? data : JSON.stringify(data);
+      return h64ToString(dataString);
+    };
+    return this.#generateDigest;
+  }
+  async #getLoaderContext({
+    collectionName,
+    loaderName = "content",
+    parseData
+  }) {
+    return {
+      collection: collectionName,
+      store: this.#store.scopedStore(collectionName),
+      meta: this.#store.metaStore(collectionName),
+      logger: this.#logger.forkIntegrationLogger(loaderName),
+      settings: this.#settings,
+      parseData,
+      generateDigest: await this.#getGenerateDigest(),
+      watcher: this.#watcher
+    };
+  }
+  async #doSync() {
+    const contentConfig = globalContentConfigObserver.get();
+    const logger = this.#logger.forkIntegrationLogger("content");
+    if (contentConfig?.status !== "loaded") {
+      logger.debug("Content config not loaded, skipping sync");
+      return;
+    }
+    if (!this.#settings.config.experimental.contentLayer) {
+      const contentLayerCollections = Object.entries(contentConfig.config.collections).filter(
+        ([_, collection]) => collection.type === CONTENT_LAYER_TYPE
+      );
+      if (contentLayerCollections.length > 0) {
+        throw new AstroUserError(
+          `The following collections have a loader defined, but the content layer is not enabled: ${contentLayerCollections.map(([title]) => title).join(", ")}.`,
+          "To enable the Content Layer API, set `experimental: { contentLayer: true }` in your Astro config file."
+        );
+      }
+      return;
+    }
+    logger.info("Syncing content");
+    const { digest: currentConfigDigest } = contentConfig.config;
+    this.#lastConfigDigest = currentConfigDigest;
+    const previousConfigDigest = await this.#store.metaStore().get("config-digest");
+    if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
+      logger.info("Content config changed, clearing cache");
+      this.#store.clearAll();
+      await this.#store.metaStore().set("config-digest", currentConfigDigest);
+    }
+    await Promise.all(
+      Object.entries(contentConfig.config.collections).map(async ([name, collection]) => {
+        if (collection.type !== CONTENT_LAYER_TYPE) {
+          return;
+        }
+        let { schema } = collection;
+        if (!schema && typeof collection.loader === "object") {
+          schema = collection.loader.schema;
+          if (typeof schema === "function") {
+            schema = await schema();
+          }
+        }
+        const collectionWithResolvedSchema = { ...collection, schema };
+        const parseData = async ({ id, data, filePath = "" }) => {
+          const { imageImports, data: parsedData } = await getEntryDataAndImages(
+            {
+              id,
+              collection: name,
+              unvalidatedData: data,
+              _internal: {
+                rawData: void 0,
+                filePath
+              }
+            },
+            collectionWithResolvedSchema,
+            false
+          );
+          if (imageImports?.length) {
+            this.#store.addAssetImports(
+              imageImports,
+              // This path may already be relative, if we're re-parsing an existing entry
+              isAbsolute(filePath) ? posixRelative(fileURLToPath(this.#settings.config.root), filePath) : filePath
+            );
+          }
+          return parsedData;
+        };
+        const context = await this.#getLoaderContext({
+          collectionName: name,
+          parseData,
+          loaderName: collection.loader.name
+        });
+        if (typeof collection.loader === "function") {
+          return simpleLoader(collection.loader, context);
+        }
+        if (!collection.loader.load) {
+          throw new Error(`Collection loader for ${name} does not have a load method`);
+        }
+        return collection.loader.load(context);
+      })
+    );
+    if (!existsSync(this.#settings.config.cacheDir)) {
+      await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
+    }
+    const cacheFile = new URL(DATA_STORE_FILE, this.#settings.config.cacheDir);
+    await this.#store.writeToDisk(cacheFile);
+    if (!existsSync(this.#settings.dotAstroDir)) {
+      await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
+    }
+    const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeAssetImports(assetImportsFile);
+    const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeModuleImports(modulesImportsFile);
+    logger.info("Synced content");
+    if (this.#settings.config.experimental.contentIntellisense) {
+      await this.regenerateCollectionFileManifest();
+    }
+  }
+  async regenerateCollectionFileManifest() {
+    const collectionsManifest = new URL("collections/collections.json", this.#settings.dotAstroDir);
+    this.#logger.debug("content", "Regenerating collection file manifest");
+    if (existsSync(collectionsManifest)) {
+      try {
+        const collections = await fs.readFile(collectionsManifest, "utf-8");
+        const collectionsJson = JSON.parse(collections);
+        collectionsJson.entries ??= {};
+        for (const { hasSchema, name } of collectionsJson.collections) {
+          if (!hasSchema) {
+            continue;
+          }
+          const entries = this.#store.values(name);
+          if (!entries?.[0]?.filePath) {
+            continue;
+          }
+          for (const { filePath } of entries) {
+            if (!filePath) {
+              continue;
+            }
+            const key = new URL(filePath, this.#settings.config.root).href.toLowerCase();
+            collectionsJson.entries[key] = name;
+          }
+        }
+        await fs.writeFile(collectionsManifest, JSON.stringify(collectionsJson, null, 2));
+      } catch {
+        this.#logger.error("content", "Failed to regenerate collection file manifest");
+      }
+    }
+    this.#logger.debug("content", "Regenerated collection file manifest");
+  }
+}
+async function simpleLoader(handler, context) {
+  const data = await handler();
+  context.store.clear();
+  for (const raw of data) {
+    const item = await context.parseData({ id: raw.id, data: raw });
+    context.store.set({ id: raw.id, data: item });
+  }
+}
+function contentLayerSingleton() {
+  let instance = null;
+  return {
+    initialized: () => Boolean(instance),
+    init: (options) => {
+      instance?.unwatchContentConfig();
+      instance = new ContentLayer(options);
+      return instance;
+    },
+    get: () => {
+      if (!instance) {
+        throw new Error("Content layer not initialized");
+      }
+      return instance;
+    },
+    dispose: () => {
+      instance?.unwatchContentConfig();
+      instance = null;
+    }
+  };
+}
+const globalContentLayer = contentLayerSingleton();
+export {
+  ContentLayer,
+  globalContentLayer,
+  simpleLoader
+};

package/dist/content/data-store.d.ts

@@ -0,0 +1,54 @@
+import type { MarkdownHeading } from '@astrojs/markdown-remark';
+export interface RenderedContent {
+    /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
+    html: string;
+    metadata?: {
+        /** Any images that are present in this entry. Relative to the {@link DataEntry} filePath. */
+        imagePaths?: Array<string>;
+        /** Any headings that are present in this file. */
+        headings?: MarkdownHeading[];
+        /** Raw frontmatter, parsed parsed from the file. This may include data from remark plugins. */
+        frontmatter?: Record<string, any>;
+        /** Any other metadata that is present in this file. */
+        [key: string]: unknown;
+    };
+}
+export interface DataEntry<TData extends Record<string, unknown> = Record<string, unknown>> {
+    /** The ID of the entry. Unique per collection. */
+    id: string;
+    /** The parsed entry data */
+    data: TData;
+    /** The file path of the content, if applicable. Relative to the site root. */
+    filePath?: string;
+    /** The raw body of the content, if applicable. */
+    body?: string;
+    /** An optional content digest, to check if the content has changed. */
+    digest?: number | string;
+    /** The rendered content of the entry, if applicable. */
+    rendered?: RenderedContent;
+    /**
+     * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase when calling `renderEntry`.
+     */
+    deferredRender?: boolean;
+}
+/**
+ * A read-only data store for content collections. This is used to retrieve data from the content layer at runtime.
+ * To add or modify data, use {@link MutableDataStore} instead.
+ */
+export declare class DataStore {
+    protected _collections: Map<string, Map<string, any>>;
+    constructor();
+    get<T = DataEntry>(collectionName: string, key: string): T | undefined;
+    entries<T = DataEntry>(collectionName: string): Array<[id: string, T]>;
+    values<T = DataEntry>(collectionName: string): Array<T>;
+    keys(collectionName: string): Array<string>;
+    has(collectionName: string, key: string): boolean;
+    hasCollection(collectionName: string): boolean;
+    collections(): Map<string, Map<string, any>>;
+    /**
+     * Attempts to load a DataStore from the virtual module.
+     * This only works in Vite.
+     */
+    static fromModule(): Promise<DataStore>;
+    static fromMap(data: Map<string, Map<string, any>>): Promise<DataStore>;
+}

package/dist/content/data-store.js

@@ -0,0 +1,72 @@
+import * as devalue from "devalue";
+class DataStore {
+  _collections = /* @__PURE__ */ new Map();
+  constructor() {
+    this._collections = /* @__PURE__ */ new Map();
+  }
+  get(collectionName, key) {
+    return this._collections.get(collectionName)?.get(String(key));
+  }
+  entries(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.entries()];
+  }
+  values(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.values()];
+  }
+  keys(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.keys()];
+  }
+  has(collectionName, key) {
+    const collection = this._collections.get(collectionName);
+    if (collection) {
+      return collection.has(String(key));
+    }
+    return false;
+  }
+  hasCollection(collectionName) {
+    return this._collections.has(collectionName);
+  }
+  collections() {
+    return this._collections;
+  }
+  /**
+   * Attempts to load a DataStore from the virtual module.
+   * This only works in Vite.
+   */
+  static async fromModule() {
+    try {
+      const data = await import("astro:data-layer-content");
+      const map = devalue.unflatten(data.default);
+      return DataStore.fromMap(map);
+    } catch {
+    }
+    return new DataStore();
+  }
+  static async fromMap(data) {
+    const store = new DataStore();
+    store._collections = data;
+    return store;
+  }
+}
+function dataStoreSingleton() {
+  let instance = void 0;
+  return {
+    get: async () => {
+      if (!instance) {
+        instance = DataStore.fromModule();
+      }
+      return instance;
+    },
+    set: (store) => {
+      instance = store;
+    }
+  };
+}
+const globalDataStore = dataStoreSingleton();
+export {
+  DataStore,
+  globalDataStore
+};