@content-collections/core 0.6.4 → 0.7.1

package/dist/index.js

@@ -1,135 +1,109 @@
-// src/config.ts
-import { z } from "zod";
+// src/builder.ts
+import path8 from "node:path";
 
-// src/utils.ts
-import camelcase from "camelcase";
-import pluralize from "pluralize";
-function generateTypeName(name) {
-  const singularName = pluralize.singular(name);
-  return camelcase(singularName, { pascalCase: true });
-}
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-function orderByPath(a, b) {
-  return a.path.localeCompare(b.path);
+// src/cache.ts
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path, { join } from "node:path";
+function createKey(config, input) {
+  return createHash("sha256").update(config).update(JSON.stringify(input)).digest("hex");
 }
-
-// src/config.ts
-var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
-function defineCollection(collection) {
-  let typeName = collection.typeName;
-  if (!typeName) {
-    typeName = generateTypeName(collection.name);
-  }
-  let parser = collection.parser;
-  if (!parser) {
-    parser = "frontmatter";
+async function createCacheDirectory(directory) {
+  const cacheDirectory = path.join(directory, ".content-collections", "cache");
+  if (!existsSync(cacheDirectory)) {
+    await mkdir(cacheDirectory, { recursive: true });
   }
-  return {
-    ...collection,
-    typeName,
-    parser,
-    schema: collection.schema(z)
-  };
+  return cacheDirectory;
 }
-function defineConfig(config) {
-  return config;
+function fileName(input) {
+  return input.replace(/[^a-z0-9]/gi, "_").toLowerCase();
 }
-
-// src/configurationReader.ts
-import * as esbuild from "esbuild";
-import fs from "fs/promises";
-import path from "path";
-import { existsSync } from "fs";
-import { createHash } from "crypto";
-var ConfigurationError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-var importPathPlugin = {
-  name: "import-path",
-  setup(build2) {
-    build2.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
-      return { path: path.join(__dirname, "index.ts"), external: true };
-    });
-  }
-};
-var defaultConfigName = "content-collection-config.mjs";
-function resolveCacheDir(config, options) {
-  if (options.cacheDir) {
-    return options.cacheDir;
+async function readMapping(mappingPath) {
+  if (existsSync(mappingPath)) {
+    try {
+      return JSON.parse(await readFile(mappingPath, "utf-8"));
+    } catch (e) {
+      console.error(
+        "Failed to parse the cache mapping. We will recreate the cache."
+      );
+    }
   }
-  return path.join(path.dirname(config), ".content-collections", "cache");
+  return {};
 }
-var externalPackagesPlugin = (configPath) => ({
-  name: "external-packages",
-  setup: (build2) => {
-    const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/;
-    build2.onResolve({ filter }, ({ path: path7 }) => {
-      const external = !path7.includes(configPath);
-      return { path: path7, external };
-    });
-  }
-});
-async function compile(configurationPath, outfile) {
-  const plugins = [
-    externalPackagesPlugin(configurationPath)
-  ];
-  if (process.env.NODE_ENV === "test") {
-    plugins.push(importPathPlugin);
+async function createCacheManager(baseDirectory, configChecksum) {
+  const cacheDirectory = await createCacheDirectory(baseDirectory);
+  const mappingPath = join(cacheDirectory, "mapping.json");
+  const mapping = await readMapping(mappingPath);
+  async function flush() {
+    await writeFile(mappingPath, JSON.stringify(mapping));
   }
-  await esbuild.build({
-    entryPoints: [configurationPath],
-    packages: "external",
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    plugins,
-    outfile
-  });
-}
-function createConfigurationReader() {
-  return async (configurationPath, options = {
-    configName: defaultConfigName
-  }) => {
-    if (!existsSync(configurationPath)) {
-      throw new ConfigurationError(
-        "Read",
-        `configuration file ${configurationPath} does not exist`
-      );
+  function cache(collection, file) {
+    const directory = join(
+      cacheDirectory,
+      fileName(collection),
+      fileName(file)
+    );
+    let collectionMapping = mapping[collection];
+    if (!collectionMapping) {
+      collectionMapping = {};
+      mapping[collection] = collectionMapping;
     }
-    const cacheDir = resolveCacheDir(configurationPath, options);
-    await fs.mkdir(cacheDir, { recursive: true });
-    const outfile = path.join(cacheDir, options.configName);
-    try {
-      await compile(configurationPath, outfile);
-    } catch (error) {
-      throw new ConfigurationError(
-        "Compile",
-        `configuration file ${configurationPath} is invalid: ${error}`
-      );
+    let fileMapping = collectionMapping[file];
+    if (!fileMapping) {
+      fileMapping = [];
+      collectionMapping[file] = fileMapping;
     }
-    const module = await import(`file://${path.resolve(outfile)}?x=${Date.now()}`);
-    const hash = createHash("sha256");
-    hash.update(await fs.readFile(outfile, "utf-8"));
-    const checksum = hash.digest("hex");
+    let newFileMapping = [];
+    const cacheFn = async (input, fn) => {
+      const key = createKey(configChecksum, input);
+      newFileMapping.push(key);
+      const filePath = join(directory, `${key}.cache`);
+      if (fileMapping?.includes(key) || newFileMapping.includes(key)) {
+        if (existsSync(filePath)) {
+          try {
+            return JSON.parse(await readFile(filePath, "utf-8"));
+          } catch (e) {
+            console.error(
+              "Failed to parse the cache file. We will recompute the value."
+            );
+          }
+        }
+      }
+      const output = await fn(input);
+      if (!existsSync(directory)) {
+        await mkdir(directory, { recursive: true });
+      }
+      await writeFile(filePath, JSON.stringify(output));
+      return output;
+    };
+    const tidyUp = async () => {
+      const filesToDelete = fileMapping?.filter((key) => !newFileMapping.includes(key)) || [];
+      for (const key of filesToDelete) {
+        const filePath = join(directory, `${key}.cache`);
+        if (existsSync(filePath)) {
+          await unlink(filePath);
+        }
+      }
+      if (collectionMapping) {
+        collectionMapping[file] = newFileMapping;
+      }
+    };
     return {
-      ...module.default,
-      path: configurationPath,
-      generateTypes: true,
-      checksum
+      cacheFn,
+      tidyUp
     };
+  }
+  return {
+    cache,
+    flush
   };
 }
 
 // src/collector.ts
-import fg from "fast-glob";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import path2 from "path";
+import { glob } from "tinyglobby";
 
 // src/parser.ts
 import matter from "gray-matter";
@@ -166,6 +140,34 @@ var parsers = {
   }
 };
 
+// src/utils.ts
+import camelcase from "camelcase";
+import pluralize from "pluralize";
+function generateTypeName(name) {
+  const singularName = pluralize.singular(name);
+  return camelcase(singularName, { pascalCase: true });
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function orderByPath(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function removeChildPaths(paths) {
+  return Array.from(
+    new Set(
+      paths.filter((path9) => {
+        return !paths.some((otherPath) => {
+          if (path9 === otherPath) {
+            return false;
+          }
+          return path9.startsWith(otherPath);
+        });
+      })
+    )
+  );
+}
+
 // src/collector.ts
 var CollectError = class extends Error {
   type;
@@ -177,7 +179,7 @@ var CollectError = class extends Error {
 function createCollector(emitter, baseDirectory = ".") {
   async function read(filePath) {
     try {
-      return await readFile(filePath, "utf-8");
+      return await readFile2(filePath, "utf-8");
     } catch (error) {
       emitter.emit("collector:read-error", {
         filePath,
@@ -187,7 +189,11 @@ function createCollector(emitter, baseDirectory = ".") {
     }
   }
   async function collectFile(collection, filePath) {
-    const absolutePath = path2.join(baseDirectory, collection.directory, filePath);
+    const absolutePath = path2.join(
+      baseDirectory,
+      collection.directory,
+      filePath
+    );
     const file = await read(absolutePath);
     if (!file) {
       return null;
@@ -218,7 +224,8 @@ function createCollector(emitter, baseDirectory = ".") {
   }
   async function resolveCollection(collection) {
     const collectionDirectory = path2.join(baseDirectory, collection.directory);
-    const filePaths = await fg(collection.include, {
+    const include = Array.isArray(collection.include) ? collection.include : [collection.include];
+    const filePaths = await glob(include, {
       cwd: collectionDirectory,
       onlyFiles: true,
       absolute: false,
@@ -245,32 +252,114 @@ function createCollector(emitter, baseDirectory = ".") {
   };
 }
 
-// src/writer.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-import pluralize2 from "pluralize";
+// src/synchronizer.ts
+import path3 from "node:path";
+import picomatch from "picomatch";
+function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
+  function findCollections(filePath) {
+    const resolvedFilePath = path3.resolve(filePath);
+    return collections.filter((collection) => {
+      return resolvedFilePath.startsWith(
+        path3.resolve(baseDirectory, collection.directory)
+      );
+    });
+  }
+  function createRelativePath(collectionPath, filePath) {
+    const resolvedCollectionPath = path3.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path3.resolve(filePath);
+    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
+    if (relativePath.startsWith(path3.sep)) {
+      relativePath = relativePath.slice(path3.sep.length);
+    }
+    return relativePath;
+  }
+  function resolve2(filePath) {
+    const collections2 = findCollections(filePath);
+    return collections2.map((collection) => {
+      const relativePath = createRelativePath(collection.directory, filePath);
+      return {
+        collection,
+        relativePath
+      };
+    }).filter(({ collection, relativePath }) => {
+      return picomatch.isMatch(relativePath, collection.include, {
+        ignore: collection.exclude
+      });
+    });
+  }
+  function deleted(filePath) {
+    const resolvedCollections = resolve2(filePath);
+    if (resolvedCollections.length === 0) {
+      return false;
+    }
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file) => file.path === relativePath
+      );
+      const deleted2 = collection.files.splice(index, 1);
+      if (deleted2.length > 0) {
+        changed2 = true;
+      }
+    }
+    return changed2;
+  }
+  async function changed(filePath) {
+    const resolvedCollections = resolve2(filePath);
+    if (resolvedCollections.length === 0) {
+      return false;
+    }
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file2) => file2.path === relativePath
+      );
+      const file = await readCollectionFile(collection, relativePath);
+      if (file) {
+        changed2 = true;
+        if (index === -1) {
+          collection.files.push(file);
+          collection.files.sort(orderByPath);
+        } else {
+          collection.files[index] = file;
+        }
+      }
+    }
+    return changed2;
+  }
+  return {
+    deleted,
+    changed
+  };
+}
+
+// src/transformer.ts
+import os from "node:os";
+import { basename, dirname, extname } from "node:path";
+import pLimit from "p-limit";
+import { z as z2 } from "zod";
 
 // src/serializer.ts
-import z2 from "zod";
 import serializeJs from "serialize-javascript";
-var literalSchema = z2.union([
+import z from "zod";
+var literalSchema = z.union([
   // json
-  z2.string(),
-  z2.number(),
-  z2.boolean(),
-  z2.null(),
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
   // serializable-javascript
-  z2.undefined(),
-  z2.date(),
-  z2.map(z2.unknown(), z2.unknown()),
-  z2.set(z2.unknown()),
-  z2.bigint()
+  z.undefined(),
+  z.date(),
+  z.map(z.unknown(), z.unknown()),
+  z.set(z.unknown()),
+  z.bigint()
 ]);
-var schema = z2.lazy(
-  () => z2.union([literalSchema, z2.array(schema), z2.record(schema)])
+var schema = z.lazy(
+  () => z.union([literalSchema, z.array(schema), z.record(schema)])
 );
 var extension = "js";
-var serializableSchema = z2.record(schema);
+var serializableSchema = z.record(schema);
 function serialize(value) {
   const serializedValue = serializeJs(value, {
     space: 2,
@@ -280,85 +369,7 @@ function serialize(value) {
   return `export default ${serializedValue};`;
 }
 
-// src/writer.ts
-function createArrayConstName(name) {
-  let suffix = name.charAt(0).toUpperCase() + name.slice(1);
-  return "all" + pluralize2(suffix);
-}
-async function createDataFile(directory, collection) {
-  const dataPath = path3.join(
-    directory,
-    `${createArrayConstName(collection.name)}.${extension}`
-  );
-  await fs2.writeFile(
-    dataPath,
-    serialize(collection.documents.map((doc) => doc.document))
-  );
-}
-function createDataFiles(directory, collections) {
-  return Promise.all(
-    collections.map((collection) => createDataFile(directory, collection))
-  );
-}
-async function createJavaScriptFile(directory, configuration) {
-  const collections = configuration.collections.map(
-    ({ name }) => createArrayConstName(name)
-  );
-  let content = `// generated by content-collections at ${/* @__PURE__ */ new Date()}
-
-`;
-  for (const name of collections) {
-    content += `import ${name} from "./${name}.${extension}";
-`;
-  }
-  content += "\n";
-  content += "export { " + collections.join(", ") + " };\n";
-  await fs2.writeFile(path3.join(directory, "index.js"), content, "utf-8");
-}
-function createImportPath(directory, target) {
-  let importPath = path3.posix.join(
-    ...path3.relative(directory, target).split(path3.sep)
-  );
-  if (!importPath.startsWith(".")) {
-    importPath = "./" + importPath;
-  }
-  return importPath;
-}
-async function createTypeDefinitionFile(directory, configuration) {
-  if (!configuration.generateTypes) {
-    return;
-  }
-  const importPath = createImportPath(directory, configuration.path);
-  let content = `import configuration from "${importPath}";
-import { GetTypeByName } from "@content-collections/core";
-`;
-  const collections = configuration.collections;
-  for (const collection of collections) {
-    content += `
-`;
-    content += `export type ${collection.typeName} = GetTypeByName<typeof configuration, "${collection.name}">;
-`;
-    content += `export declare const ${createArrayConstName(
-      collection.name
-    )}: Array<${collection.typeName}>;
-`;
-  }
-  content += "\n";
-  content += "export {};\n";
-  await fs2.writeFile(path3.join(directory, "index.d.ts"), content, "utf-8");
-}
-async function createWriter(directory) {
-  await fs2.mkdir(directory, { recursive: true });
-  return {
-    createJavaScriptFile: (configuration) => createJavaScriptFile(directory, configuration),
-    createTypeDefinitionFile: (configuration) => createTypeDefinitionFile(directory, configuration),
-    createDataFiles: (collections) => createDataFiles(directory, collections)
-  };
-}
-
 // src/transformer.ts
-import { basename, dirname, extname } from "path";
-import { z as z3 } from "zod";
 var TransformError = class extends Error {
   type;
   constructor(type, message) {
@@ -366,8 +377,8 @@ var TransformError = class extends Error {
     this.type = type;
   }
 };
-function createPath(path7, ext) {
-  let p = path7.slice(0, -ext.length);
+function createPath(path9, ext) {
+  let p = path9.slice(0, -ext.length);
   if (p.endsWith("/index")) {
     p = p.slice(0, -6);
   }
@@ -377,15 +388,15 @@ function createTransformer(emitter, cacheManager) {
   function createSchema(parserName, schema2) {
     const parser = parsers[parserName];
     if (!parser.hasContent) {
-      return z3.object(schema2);
+      return z2.object(schema2);
     }
-    return z3.object({
-      content: z3.string(),
+    return z2.object({
+      content: z2.string(),
       ...schema2
     });
   }
   async function parseFile(collection, file) {
-    const { data, path: path7 } = file;
+    const { data, path: path9 } = file;
     const schema2 = createSchema(collection.parser, collection.schema);
     let parsedData = await schema2.safeParseAsync(data);
     if (!parsedData.success) {
@@ -396,7 +407,7 @@ function createTransformer(emitter, cacheManager) {
       });
       return null;
     }
-    const ext = extname(path7);
+    const ext = extname(path9);
     let extension2 = ext;
     if (extension2.startsWith(".")) {
       extension2 = extension2.slice(1);
@@ -404,11 +415,11 @@ function createTransformer(emitter, cacheManager) {
     const document = {
       ...parsedData.data,
       _meta: {
-        filePath: path7,
-        fileName: basename(path7),
-        directory: dirname(path7),
+        filePath: path9,
+        fileName: basename(path9),
+        directory: dirname(path9),
         extension: extension2,
-        path: createPath(path7, ext)
+        path: createPath(path9, ext)
       }
     };
     return {
@@ -438,43 +449,48 @@ function createTransformer(emitter, cacheManager) {
       },
       collection: {
         name: collection.name,
-        directory: collection.directory
+        directory: collection.directory,
+        documents: async () => {
+          return collection.documents.map((doc) => doc.document);
+        }
       },
       cache: cache.cacheFn
     };
   }
-  async function transformCollection(collections, collection) {
-    if (collection.transform) {
-      const docs = [];
-      for (const doc of collection.documents) {
-        const cache = cacheManager.cache(
-          collection.name,
-          doc.document._meta.path
-        );
-        const context = createContext(collections, collection, cache);
-        try {
-          const document = await collection.transform(doc.document, context);
-          docs.push({
-            ...doc,
-            document
-          });
-          await cache.tidyUp();
-        } catch (error) {
-          if (error instanceof TransformError) {
-            emitter.emit("transformer:error", {
-              collection,
-              error
-            });
-          } else {
-            emitter.emit("transformer:error", {
-              collection,
-              error: new TransformError("Transform", String(error))
-            });
-          }
-        }
+  async function transformDocument(collections, collection, transform, doc) {
+    const cache = cacheManager.cache(collection.name, doc.document._meta.path);
+    const context2 = createContext(collections, collection, cache);
+    try {
+      const document = await transform(doc.document, context2);
+      await cache.tidyUp();
+      return {
+        ...doc,
+        document
+      };
+    } catch (error) {
+      if (error instanceof TransformError) {
+        emitter.emit("transformer:error", {
+          collection,
+          error
+        });
+      } else {
+        emitter.emit("transformer:error", {
+          collection,
+          error: new TransformError("Transform", String(error))
+        });
       }
+    }
+  }
+  async function transformCollection(collections, collection) {
+    const transform = collection.transform;
+    if (transform) {
+      const limit = pLimit(os.cpus().length);
+      const docs = collection.documents.map(
+        (doc) => limit(() => transformDocument(collections, collection, transform, doc))
+      );
+      const transformed = await Promise.all(docs);
       await cacheManager.flush();
-      return docs;
+      return transformed.filter(isDefined);
     }
     return collection.documents;
   }
@@ -507,127 +523,460 @@ function createTransformer(emitter, cacheManager) {
   };
 }
 
-// src/synchronizer.ts
-import micromatch from "micromatch";
-import path4 from "path";
-function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollections(filePath) {
-    const resolvedFilePath = path4.resolve(filePath);
-    return collections.filter((collection) => {
-      return resolvedFilePath.startsWith(
-        path4.resolve(baseDirectory, collection.directory)
-      );
-    });
+// src/writer.ts
+import fs from "node:fs/promises";
+import path4 from "node:path";
+import pluralize2 from "pluralize";
+function createArrayConstName(name) {
+  let suffix = name.charAt(0).toUpperCase() + name.slice(1);
+  return "all" + pluralize2(suffix);
+}
+async function createDataFile(directory, collection) {
+  const dataPath = path4.join(
+    directory,
+    `${createArrayConstName(collection.name)}.${extension}`
+  );
+  await fs.writeFile(
+    dataPath,
+    serialize(collection.documents.map((doc) => doc.document))
+  );
+}
+function createDataFiles(directory, collections) {
+  return Promise.all(
+    collections.map((collection) => createDataFile(directory, collection))
+  );
+}
+async function createJavaScriptFile(directory, configuration) {
+  const collections = configuration.collections.map(
+    ({ name }) => createArrayConstName(name)
+  );
+  let content = `// generated by content-collections at ${/* @__PURE__ */ new Date()}
+
+`;
+  for (const name of collections) {
+    content += `import ${name} from "./${name}.${extension}";
+`;
   }
-  function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = path4.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = path4.resolve(filePath);
-    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith(path4.sep)) {
-      relativePath = relativePath.slice(path4.sep.length);
-    }
-    return relativePath;
+  content += "\n";
+  content += "export { " + collections.join(", ") + " };\n";
+  await fs.writeFile(path4.join(directory, "index.js"), content, "utf-8");
+}
+function createImportPath(directory, target) {
+  let importPath = path4.posix.join(
+    ...path4.relative(directory, target).split(path4.sep)
+  );
+  if (!importPath.startsWith(".")) {
+    importPath = "./" + importPath;
   }
-  function resolve(filePath) {
-    const collections2 = findCollections(filePath);
-    return collections2.map((collection) => {
-      const relativePath = createRelativePath(collection.directory, filePath);
-      return {
-        collection,
-        relativePath
-      };
-    }).filter(({ collection, relativePath }) => {
-      return micromatch.isMatch(relativePath, collection.include, {
-        ignore: collection.exclude
-      });
-    });
+  return importPath;
+}
+async function createTypeDefinitionFile(directory, configuration) {
+  if (!configuration.generateTypes) {
+    return;
   }
-  function deleted(filePath) {
-    const resolvedCollections = resolve(filePath);
-    if (resolvedCollections.length === 0) {
-      return false;
+  const importPath = createImportPath(directory, configuration.path);
+  let content = `import configuration from "${importPath}";
+import { GetTypeByName } from "@content-collections/core";
+`;
+  const collections = configuration.collections;
+  for (const collection of collections) {
+    content += `
+`;
+    content += `export type ${collection.typeName} = GetTypeByName<typeof configuration, "${collection.name}">;
+`;
+    content += `export declare const ${createArrayConstName(
+      collection.name
+    )}: Array<${collection.typeName}>;
+`;
+  }
+  content += "\n";
+  content += "export {};\n";
+  await fs.writeFile(path4.join(directory, "index.d.ts"), content, "utf-8");
+}
+async function createWriter(directory) {
+  await fs.mkdir(directory, { recursive: true });
+  return {
+    createJavaScriptFile: (configuration) => createJavaScriptFile(directory, configuration),
+    createTypeDefinitionFile: (configuration) => createTypeDefinitionFile(directory, configuration),
+    createDataFiles: (collections) => createDataFiles(directory, collections)
+  };
+}
+
+// src/build.ts
+async function createBuildContext({
+  emitter,
+  outputDirectory,
+  baseDirectory,
+  configuration
+}) {
+  const collector = createCollector(emitter, baseDirectory);
+  const [writer, resolved, cacheManager] = await Promise.all([
+    createWriter(outputDirectory),
+    collector.collect(configuration.collections),
+    createCacheManager(baseDirectory, configuration.checksum)
+  ]);
+  const synchronizer = createSynchronizer(
+    collector.collectFile,
+    resolved,
+    baseDirectory
+  );
+  const transform = createTransformer(emitter, cacheManager);
+  return {
+    resolved,
+    writer,
+    synchronizer,
+    transform,
+    emitter,
+    cacheManager,
+    configuration
+  };
+}
+async function build({
+  emitter,
+  transform,
+  resolved,
+  writer,
+  configuration
+}) {
+  const startedAt = Date.now();
+  emitter.emit("builder:start", {
+    startedAt
+  });
+  const collections = await transform(resolved);
+  await Promise.all([
+    writer.createDataFiles(collections),
+    writer.createTypeDefinitionFile(configuration),
+    writer.createJavaScriptFile(configuration)
+  ]);
+  const pendingOnSuccess = collections.filter((collection) => Boolean(collection.onSuccess)).map(
+    (collection) => collection.onSuccess?.(collection.documents.map((doc) => doc.document))
+  );
+  await Promise.all(pendingOnSuccess.filter(isDefined));
+  const stats = collections.reduce(
+    (acc, collection) => {
+      acc.collections++;
+      acc.documents += collection.documents.length;
+      return acc;
+    },
+    {
+      collections: 0,
+      documents: 0
     }
-    let changed2 = false;
-    for (const { collection, relativePath } of resolvedCollections) {
-      const index = collection.files.findIndex(
-        (file) => file.path === relativePath
-      );
-      const deleted2 = collection.files.splice(index, 1);
-      if (deleted2.length > 0) {
-        changed2 = true;
+  );
+  emitter.emit("builder:end", {
+    startedAt,
+    endedAt: Date.now(),
+    stats
+  });
+}
+
+// src/configurationReader.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import fs3 from "node:fs/promises";
+import path6 from "node:path";
+
+// ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.21.4/node_modules/bundle-require/dist/index.js
+import {
+  build as build2,
+  context
+} from "esbuild";
+
+// ../../node_modules/.pnpm/load-tsconfig@0.2.5/node_modules/load-tsconfig/dist/index.js
+import path5 from "path";
+import fs2 from "fs";
+import { createRequire } from "module";
+var singleComment = Symbol("singleComment");
+var multiComment = Symbol("multiComment");
+var stripWithoutWhitespace = () => "";
+var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\S/g, " ");
+var isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
       }
     }
-    return changed2;
-  }
-  async function changed(filePath) {
-    const resolvedCollections = resolve(filePath);
-    if (resolvedCollections.length === 0) {
-      return false;
+    if (isInsideString) {
+      continue;
     }
-    let changed2 = false;
-    for (const { collection, relativePath } of resolvedCollections) {
-      const index = collection.files.findIndex(
-        (file2) => file2.path === relativePath
-      );
-      const file = await readCollectionFile(collection, relativePath);
-      if (file) {
-        changed2 = true;
-        if (index === -1) {
-          collection.files.push(file);
-          collection.files.sort(orderByPath);
-        } else {
-          collection.files[index] = file;
+    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+      continue;
+    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
         }
+      } else if (currentCharacter === ",") {
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
       }
     }
-    return changed2;
   }
-  return {
-    deleted,
-    changed
-  };
+  return result + buffer + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
 }
-
-// src/builder.ts
-import path6 from "path";
-
-// src/watcher.ts
-import * as watcher from "@parcel/watcher";
-async function createWatcher(emitter, paths, sync, build2) {
-  const onChange = async (error, events) => {
-    if (error) {
-      console.error(error);
-      return;
+function jsoncParse(data) {
+  try {
+    return new Function("return " + stripJsonComments(data).trim())();
+  } catch (_) {
+    return {};
+  }
+}
+var req = true ? createRequire(import.meta.url) : __require;
+var findUp = (name, startDir, stopDir = path5.parse(startDir).root) => {
+  let dir = startDir;
+  while (dir !== stopDir) {
+    const file = path5.join(dir, name);
+    if (fs2.existsSync(file))
+      return file;
+    if (!file.endsWith(".json")) {
+      const fileWithExt = file + ".json";
+      if (fs2.existsSync(fileWithExt))
+        return fileWithExt;
     }
-    let rebuild = false;
-    for (const event of events) {
-      if (await sync(event.type, event.path)) {
-        emitter.emit("watcher:file-changed", {
-          filePath: event.path,
-          modification: event.type
+    dir = path5.dirname(dir);
+  }
+  return null;
+};
+var resolveTsConfigFromFile = (cwd, filename) => {
+  if (path5.isAbsolute(filename))
+    return fs2.existsSync(filename) ? filename : null;
+  return findUp(filename, cwd);
+};
+var resolveTsConfigFromExtends = (cwd, name) => {
+  if (path5.isAbsolute(name))
+    return fs2.existsSync(name) ? name : null;
+  if (name.startsWith("."))
+    return findUp(name, cwd);
+  const id = req.resolve(name, { paths: [cwd] });
+  return id;
+};
+var loadTsConfigInternal = (dir = process.cwd(), name = "tsconfig.json", isExtends = false) => {
+  var _a, _b;
+  dir = path5.resolve(dir);
+  const id = isExtends ? resolveTsConfigFromExtends(dir, name) : resolveTsConfigFromFile(dir, name);
+  if (!id)
+    return null;
+  const data = jsoncParse(fs2.readFileSync(id, "utf-8"));
+  const configDir = path5.dirname(id);
+  if ((_a = data.compilerOptions) == null ? void 0 : _a.baseUrl) {
+    data.compilerOptions.baseUrl = path5.join(
+      configDir,
+      data.compilerOptions.baseUrl
+    );
+  }
+  let extendsFiles = [];
+  if (data.extends) {
+    const extendsList = Array.isArray(data.extends) ? data.extends : [data.extends];
+    const extendsData = {};
+    for (const name2 of extendsList) {
+      const parentConfig = loadTsConfigInternal(configDir, name2, true);
+      if (parentConfig) {
+        Object.assign(extendsData, {
+          ...parentConfig == null ? void 0 : parentConfig.data,
+          compilerOptions: {
+            ...extendsData.compilerOptions,
+            ...(_b = parentConfig == null ? void 0 : parentConfig.data) == null ? void 0 : _b.compilerOptions
+          }
         });
-        rebuild = true;
+        extendsFiles.push(...parentConfig.files);
       }
     }
-    if (rebuild) {
-      await build2();
+    Object.assign(data, {
+      ...extendsData,
+      ...data,
+      compilerOptions: {
+        ...extendsData.compilerOptions,
+        ...data.compilerOptions
+      }
+    });
+  }
+  delete data.extends;
+  return { path: id, data, files: [...extendsFiles, id] };
+};
+var loadTsConfig = (dir, name) => loadTsConfigInternal(dir, name);
+
+// ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.21.4/node_modules/bundle-require/dist/index.js
+var tsconfigPathsToRegExp = (paths) => {
+  return Object.keys(paths || {}).map((key) => {
+    return new RegExp(`^${key.replace(/\*/, ".*")}$`);
+  });
+};
+var match = (id, patterns) => {
+  if (!patterns)
+    return false;
+  return patterns.some((p) => {
+    if (p instanceof RegExp) {
+      return p.test(id);
     }
-  };
-  const subscriptions = await Promise.all(
-    paths.map((path7) => watcher.subscribe(path7, onChange))
-  );
+    return id === p || id.startsWith(p + "/");
+  });
+};
+
+// src/esbuild.ts
+import { build as build3 } from "esbuild";
+import { dirname as dirname2, join as join2 } from "node:path";
+function tsconfigResolvePaths(configPath) {
+  let tsconfig = loadTsConfig(dirname2(configPath));
+  if (!tsconfig) {
+    tsconfig = loadTsConfig();
+  }
+  return tsconfig?.data?.compilerOptions?.paths || {};
+}
+function createExternalsPlugin(configPath) {
+  const resolvedPaths = tsconfigResolvePaths(configPath);
+  const resolvePatterns = tsconfigPathsToRegExp(resolvedPaths);
   return {
-    unsubscribe: async () => {
-      await Promise.all(
-        subscriptions.map((subscription) => subscription.unsubscribe())
+    name: "external-packages",
+    setup: (build4) => {
+      const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/;
+      build4.onResolve({ filter }, ({ path: path9, kind }) => {
+        if (match(path9, resolvePatterns)) {
+          if (kind === "dynamic-import") {
+            return { path: path9, external: true };
+          }
+          return;
+        }
+        return { path: path9, external: true };
+      });
+    }
+  };
+}
+var importPathPlugin = {
+  name: "import-path",
+  setup(build4) {
+    build4.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
+      return { path: join2(__dirname, "index.ts"), external: true };
+    });
+  }
+};
+async function compile(configurationPath, outfile) {
+  const plugins = [createExternalsPlugin(configurationPath)];
+  if (process.env.NODE_ENV === "test") {
+    plugins.push(importPathPlugin);
+  }
+  const result = await build3({
+    entryPoints: [configurationPath],
+    packages: "external",
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    plugins,
+    outfile,
+    metafile: true
+  });
+  return Object.keys(result.metafile.inputs);
+}
+
+// src/configurationReader.ts
+var ConfigurationError = class extends Error {
+  type;
+  constructor(type, message) {
+    super(message);
+    this.type = type;
+  }
+};
+var defaultConfigName = "content-collection-config.mjs";
+function resolveCacheDir(config, options) {
+  if (options.cacheDir) {
+    return options.cacheDir;
+  }
+  return path6.join(path6.dirname(config), ".content-collections", "cache");
+}
+function createConfigurationReader() {
+  return async (configurationPath, options = {
+    configName: defaultConfigName
+  }) => {
+    if (!existsSync2(configurationPath)) {
+      throw new ConfigurationError(
+        "Read",
+        `configuration file ${configurationPath} does not exist`
+      );
+    }
+    const cacheDir = resolveCacheDir(configurationPath, options);
+    await fs3.mkdir(cacheDir, { recursive: true });
+    const outfile = path6.join(cacheDir, options.configName);
+    try {
+      const configurationPaths = await compile(configurationPath, outfile);
+      const module = await import(`file://${path6.resolve(outfile)}?x=${Date.now()}`);
+      const hash = createHash2("sha256");
+      hash.update(await fs3.readFile(outfile, "utf-8"));
+      const checksum = hash.digest("hex");
+      return {
+        ...module.default,
+        path: configurationPath,
+        inputPaths: configurationPaths.map((p) => path6.resolve(p)),
+        generateTypes: true,
+        checksum
+      };
+    } catch (error) {
+      throw new ConfigurationError(
+        "Compile",
+        `configuration file ${configurationPath} is invalid: ${error}`
       );
-      return;
     }
   };
 }
 
 // src/events.ts
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 function isEventWithError(event) {
   return typeof event === "object" && event !== null && "error" in event;
 }
@@ -655,102 +1004,43 @@ function createEmitter() {
   };
 }
 
-// src/cache.ts
-import path5, { join } from "path";
-import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { createHash as createHash2 } from "crypto";
-function createKey(config, input) {
-  return createHash2("sha256").update(config).update(JSON.stringify(input)).digest("hex");
-}
-async function createCacheDirectory(directory) {
-  const cacheDirectory = path5.join(directory, ".content-collections", "cache");
-  if (!existsSync2(cacheDirectory)) {
-    await mkdir(cacheDirectory, { recursive: true });
-  }
-  return cacheDirectory;
-}
-function fileName(input) {
-  return input.replace(/[^a-z0-9]/gi, "_").toLowerCase();
-}
-async function readMapping(mappingPath) {
-  if (existsSync2(mappingPath)) {
-    try {
-      return JSON.parse(await readFile2(mappingPath, "utf-8"));
-    } catch (e) {
-      console.error(
-        "Failed to parse the cache mapping. We will recreate the cache."
-      );
-    }
-  }
-  return {};
-}
-async function createCacheManager(baseDirectory, configChecksum) {
-  const cacheDirectory = await createCacheDirectory(baseDirectory);
-  const mappingPath = join(cacheDirectory, "mapping.json");
-  const mapping = await readMapping(mappingPath);
-  async function flush() {
-    await writeFile(mappingPath, JSON.stringify(mapping));
-  }
-  function cache(collection, file) {
-    const directory = join(
-      cacheDirectory,
-      fileName(collection),
-      fileName(file)
-    );
-    let collectionMapping = mapping[collection];
-    if (!collectionMapping) {
-      collectionMapping = {};
-      mapping[collection] = collectionMapping;
+// src/watcher.ts
+import * as watcher from "@parcel/watcher";
+import path7, { dirname as dirname3, resolve } from "node:path";
+async function createWatcher(emitter, baseDirectory, configuration, sync) {
+  const onChange = async (error, events) => {
+    if (error) {
+      emitter.emit("watcher:subscribe-error", {
+        paths,
+        error
+      });
+      return;
     }
-    let fileMapping = collectionMapping[file];
-    if (!fileMapping) {
-      fileMapping = [];
-      collectionMapping[file] = fileMapping;
+    for (const event of events) {
+      await sync(event.type, event.path);
     }
-    let newFileMapping = [];
-    const cacheFn = async (input, fn) => {
-      const key = createKey(configChecksum, input);
-      newFileMapping.push(key);
-      const filePath = join(directory, `${key}.cache`);
-      if (fileMapping?.includes(key) || newFileMapping.includes(key)) {
-        if (existsSync2(filePath)) {
-          try {
-            return JSON.parse(await readFile2(filePath, "utf-8"));
-          } catch (e) {
-            console.error(
-              "Failed to parse the cache file. We will recompute the value."
-            );
-          }
-        }
-      }
-      const output = await fn(input);
-      if (!existsSync2(directory)) {
-        await mkdir(directory, { recursive: true });
-      }
-      await writeFile(filePath, JSON.stringify(output));
-      return output;
-    };
-    const tidyUp = async () => {
-      const filesToDelete = fileMapping?.filter((key) => !newFileMapping.includes(key)) || [];
-      for (const key of filesToDelete) {
-        const filePath = join(directory, `${key}.cache`);
-        if (existsSync2(filePath)) {
-          await unlink(filePath);
-        }
-      }
-      if (collectionMapping) {
-        collectionMapping[file] = newFileMapping;
-      }
-    };
-    return {
-      cacheFn,
-      tidyUp
-    };
-  }
+  };
+  const paths = removeChildPaths([
+    ...configuration.collections.map((collection) => path7.join(baseDirectory, collection.directory)).map((p) => resolve(p)),
+    ...configuration.inputPaths.map((p) => dirname3(p))
+  ]);
+  const subscriptions = (await Promise.all(paths.map((path9) => watcher.subscribe(path9, onChange)))).filter(isDefined);
+  emitter.emit("watcher:subscribed", {
+    paths
+  });
   return {
-    cache,
-    flush
+    unsubscribe: async () => {
+      if (!subscriptions || subscriptions.length === 0) {
+        return;
+      }
+      await Promise.all(
+        subscriptions.map((subscription) => subscription.unsubscribe())
+      );
+      emitter.emit("watcher:unsubscribed", {
+        paths
+      });
+      return;
+    }
   };
 }
 
@@ -759,69 +1049,137 @@ function resolveOutputDir(baseDirectory, options) {
   if (options.outputDir) {
     return options.outputDir;
   }
-  return path6.join(baseDirectory, ".content-collections", "generated");
+  return path8.join(baseDirectory, ".content-collections", "generated");
 }
+var ConfigurationReloadError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
 async function createBuilder(configurationPath, options = {
   configName: defaultConfigName
-}) {
-  const emitter = createEmitter();
+}, emitter = createEmitter()) {
   const readConfiguration = createConfigurationReader();
-  const configuration = await readConfiguration(configurationPath, options);
-  const baseDirectory = path6.dirname(configurationPath);
-  const directory = resolveOutputDir(baseDirectory, options);
-  const collector = createCollector(emitter, baseDirectory);
-  const writer = await createWriter(directory);
-  const [resolved] = await Promise.all([
-    collector.collect(configuration.collections),
-    writer.createJavaScriptFile(configuration),
-    writer.createTypeDefinitionFile(configuration)
-  ]);
-  const synchronizer = createSynchronizer(
-    collector.collectFile,
-    resolved,
-    baseDirectory
-  );
-  const cacheManager = await createCacheManager(baseDirectory, configuration.checksum);
-  const transform = createTransformer(emitter, cacheManager);
+  const baseDirectory = path8.dirname(configurationPath);
+  const outputDirectory = resolveOutputDir(baseDirectory, options);
+  emitter.emit("builder:created", {
+    createdAt: Date.now(),
+    configurationPath,
+    outputDirectory
+  });
+  let configuration = await readConfiguration(configurationPath, options);
+  let watcher2 = null;
+  let context2 = await createBuildContext({
+    emitter,
+    baseDirectory,
+    outputDirectory,
+    configuration
+  });
   async function sync(modification, filePath) {
-    if (modification === "delete") {
-      return synchronizer.deleted(filePath);
+    if (configuration.inputPaths.includes(filePath)) {
+      if (await onConfigurationChange()) {
+        emitter.emit("watcher:config-changed", {
+          filePath,
+          modification
+        });
+        await build(context2);
+        return true;
+      }
+    } else {
+      if (await onFileChange(modification, filePath)) {
+        emitter.emit("watcher:file-changed", {
+          filePath,
+          modification
+        });
+        await build(context2);
+        return true;
+      }
     }
-    return synchronizer.changed(filePath);
+    return false;
   }
-  async function build2() {
-    const startedAt = Date.now();
-    emitter.emit("builder:start", {
-      startedAt
-    });
-    const collections = await transform(resolved);
-    await writer.createDataFiles(collections);
-    const pendingOnSuccess = collections.filter((collection) => Boolean(collection.onSuccess)).map(
-      (collection) => collection.onSuccess?.(collection.documents.map((doc) => doc.document))
-    );
-    await Promise.all(pendingOnSuccess.filter(isDefined));
-    emitter.emit("builder:end", {
-      startedAt,
-      endedAt: Date.now()
+  async function onConfigurationChange() {
+    try {
+      configuration = await readConfiguration(configurationPath, options);
+    } catch (error) {
+      emitter.emit("watcher:config-reload-error", {
+        error: new ConfigurationReloadError(
+          `Failed to reload configuration: ${error}`
+        ),
+        configurationPath
+      });
+      return false;
+    }
+    if (watcher2) {
+      await watcher2.unsubscribe();
+    }
+    context2 = await createBuildContext({
+      emitter,
+      baseDirectory,
+      outputDirectory,
+      configuration
     });
+    if (watcher2) {
+      watcher2 = await createWatcher(
+        emitter,
+        baseDirectory,
+        configuration,
+        sync
+      );
+    }
+    return true;
+  }
+  async function onFileChange(modification, filePath) {
+    const { synchronizer } = context2;
+    if (modification === "delete") {
+      return synchronizer.deleted(filePath);
+    } else {
+      return synchronizer.changed(filePath);
+    }
   }
   async function watch() {
-    const paths = resolved.map(
-      (collection) => path6.join(baseDirectory, collection.directory)
-    );
-    const watcher2 = await createWatcher(emitter, paths, sync, build2);
-    return watcher2;
+    watcher2 = await createWatcher(emitter, baseDirectory, configuration, sync);
+    return {
+      unsubscribe: async () => {
+        if (watcher2) {
+          await watcher2.unsubscribe();
+        }
+      }
+    };
   }
   return {
+    build: () => build(context2),
     sync,
-    build: build2,
     watch,
     on: emitter.on
   };
 }
+
+// src/config.ts
+import { z as z3 } from "zod";
+var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
+function defineCollection(collection) {
+  let typeName = collection.typeName;
+  if (!typeName) {
+    typeName = generateTypeName(collection.name);
+  }
+  let parser = collection.parser;
+  if (!parser) {
+    parser = "frontmatter";
+  }
+  return {
+    ...collection,
+    typeName,
+    parser,
+    schema: collection.schema(z3)
+  };
+}
+function defineConfig(config) {
+  return config;
+}
 export {
   CollectError,
   ConfigurationError,
+  ConfigurationReloadError,
   TransformError,
   createBuilder,
   defineCollection,