@content-collections/core 0.7.0 → 0.7.2

package/dist/index.js

@@ -1,244 +1,109 @@
-// src/config.ts
-import { z } from "zod";
-
-// 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((path8) => {
-        return !paths.some((otherPath) => {
-          if (path8 === otherPath) {
-            return false;
-          }
-          return path8.startsWith(otherPath);
-        });
-      })
-    )
-  );
-}
-
-// 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";
-  }
-  return {
-    ...collection,
-    typeName,
-    parser,
-    schema: collection.schema(z)
-  };
-}
-function defineConfig(config) {
-  return config;
-}
-
-// src/configurationReader.ts
-import fs from "fs/promises";
-import path from "path";
-import { existsSync } from "fs";
-import { createHash } from "crypto";
+// src/builder.ts
+import path8 from "node:path";
 
-// src/esbuild.ts
-import { build } from "esbuild";
-import { match, loadTsConfig, tsconfigPathsToRegExp } from "bundle-require";
-import { dirname, join } from "path";
-function tsconfigResolvePaths(configPath) {
-  let tsconfig = loadTsConfig(dirname(configPath));
-  if (!tsconfig) {
-    tsconfig = loadTsConfig();
-  }
-  return tsconfig?.data?.compilerOptions?.paths || {};
-}
-function createExternalsPlugin(configPath) {
-  const resolvedPaths = tsconfigResolvePaths(configPath);
-  const resolvePatterns = tsconfigPathsToRegExp(resolvedPaths);
-  return {
-    name: "external-packages",
-    setup: (build3) => {
-      const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/;
-      build3.onResolve({ filter }, ({ path: path8, kind }) => {
-        if (match(path8, resolvePatterns)) {
-          if (kind === "dynamic-import") {
-            return { path: path8, external: true };
-          }
-          return;
-        }
-        return { path: path8, external: true };
-      });
-    }
-  };
+// 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");
 }
-var importPathPlugin = {
-  name: "import-path",
-  setup(build3) {
-    build3.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
-      return { path: join(__dirname, "index.ts"), external: true };
-    });
-  }
-};
-async function compile(configurationPath, outfile) {
-  const plugins = [createExternalsPlugin(configurationPath)];
-  if (process.env.NODE_ENV === "test") {
-    plugins.push(importPathPlugin);
+async function createCacheDirectory(directory) {
+  const cacheDirectory = path.join(directory, ".content-collections", "cache");
+  if (!existsSync(cacheDirectory)) {
+    await mkdir(cacheDirectory, { recursive: true });
   }
-  const result = await build({
-    entryPoints: [configurationPath],
-    packages: "external",
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    plugins,
-    outfile,
-    metafile: true
-  });
-  return Object.keys(result.metafile.inputs);
+  return cacheDirectory;
 }
-
-// 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 path.join(path.dirname(config), ".content-collections", "cache");
+function fileName(input) {
+  return input.replace(/[^a-z0-9]/gi, "_").toLowerCase();
 }
-function createConfigurationReader() {
-  return async (configurationPath, options = {
-    configName: defaultConfigName
-  }) => {
-    if (!existsSync(configurationPath)) {
-      throw new ConfigurationError(
-        "Read",
-        `configuration file ${configurationPath} does not exist`
-      );
-    }
-    const cacheDir = resolveCacheDir(configurationPath, options);
-    await fs.mkdir(cacheDir, { recursive: true });
-    const outfile = path.join(cacheDir, options.configName);
+async function readMapping(mappingPath) {
+  if (existsSync(mappingPath)) {
     try {
-      const configurationPaths = await compile(configurationPath, outfile);
-      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");
-      return {
-        ...module.default,
-        path: configurationPath,
-        inputPaths: configurationPaths.map((p) => path.resolve(p)),
-        generateTypes: true,
-        checksum
-      };
-    } catch (error) {
-      throw new ConfigurationError(
-        "Compile",
-        `configuration file ${configurationPath} is invalid: ${error}`
+      return JSON.parse(await readFile(mappingPath, "utf-8"));
+    } catch (e) {
+      console.error(
+        "Failed to parse the cache mapping. We will recreate the cache."
       );
     }
-  };
+  }
+  return {};
 }
-
-// src/builder.ts
-import path7 from "path";
-
-// src/watcher.ts
-import * as watcher from "@parcel/watcher";
-import path2, { dirname as dirname2, resolve } from "path";
-async function createWatcher(emitter, baseDirectory, configuration, sync) {
-  const onChange = async (error, events) => {
-    if (error) {
-      emitter.emit("watcher:subscribe-error", {
-        paths,
-        error
-      });
-      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;
     }
-    for (const event of events) {
-      await sync(event.type, event.path);
+    let fileMapping = collectionMapping[file];
+    if (!fileMapping) {
+      fileMapping = [];
+      collectionMapping[file] = fileMapping;
     }
-  };
-  const paths = removeChildPaths([
-    ...configuration.collections.map((collection) => path2.join(baseDirectory, collection.directory)).map((p) => resolve(p)),
-    ...configuration.inputPaths.map((p) => dirname2(p))
-  ]);
-  const subscriptions = (await Promise.all(paths.map((path8) => watcher.subscribe(path8, onChange)))).filter(isDefined);
-  emitter.emit("watcher:subscribed", {
-    paths
-  });
-  return {
-    unsubscribe: async () => {
-      if (!subscriptions || subscriptions.length === 0) {
-        return;
+    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."
+            );
+          }
+        }
       }
-      await Promise.all(
-        subscriptions.map((subscription) => subscription.unsubscribe())
-      );
-      emitter.emit("watcher:unsubscribed", {
-        paths
-      });
-      return;
-    }
-  };
-}
-
-// src/events.ts
-import { EventEmitter } from "events";
-function isEventWithError(event) {
-  return typeof event === "object" && event !== null && "error" in event;
-}
-function createEmitter() {
-  const emitter = new EventEmitter();
-  function on(key, listener) {
-    emitter.on(key, listener);
-  }
-  function emit(key, event) {
-    emitter.emit(key, event);
-    if (isEventWithError(event)) {
-      emitter.emit("_error", {
-        ...event,
-        _event: key
-      });
-    }
-    emitter.emit("_all", {
-      ...event,
-      _event: key
-    });
+      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 {
+      cacheFn,
+      tidyUp
+    };
   }
   return {
-    on,
-    emit
+    cache,
+    flush
   };
 }
 
 // src/collector.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
 import { glob } from "tinyglobby";
-import { readFile } from "fs/promises";
-import path3 from "path";
 
 // src/parser.ts
 import matter from "gray-matter";
@@ -260,20 +125,48 @@ function frontmatterParser(fileContent) {
     content: content.trim()
   };
 }
-var parsers = {
-  frontmatter: {
-    hasContent: true,
-    parse: frontmatterParser
-  },
-  json: {
-    hasContent: false,
-    parse: JSON.parse
-  },
-  yaml: {
-    hasContent: false,
-    parse: parseYaml
-  }
-};
+var parsers = {
+  frontmatter: {
+    hasContent: true,
+    parse: frontmatterParser
+  },
+  json: {
+    hasContent: false,
+    parse: JSON.parse
+  },
+  yaml: {
+    hasContent: false,
+    parse: parseYaml
+  }
+};
+
+// 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 {
@@ -286,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,
@@ -296,7 +189,11 @@ function createCollector(emitter, baseDirectory = ".") {
     }
   }
   async function collectFile(collection, filePath) {
-    const absolutePath = path3.join(baseDirectory, collection.directory, filePath);
+    const absolutePath = path2.join(
+      baseDirectory,
+      collection.directory,
+      filePath
+    );
     const file = await read(absolutePath);
     if (!file) {
       return null;
@@ -309,7 +206,7 @@ function createCollector(emitter, baseDirectory = ".") {
       };
     } catch (error) {
       emitter.emit("collector:parse-error", {
-        filePath: path3.join(collection.directory, filePath),
+        filePath: path2.join(collection.directory, filePath),
         error: new CollectError("Parse", String(error))
       });
       return null;
@@ -326,7 +223,7 @@ function createCollector(emitter, baseDirectory = ".") {
     return void 0;
   }
   async function resolveCollection(collection) {
-    const collectionDirectory = path3.join(baseDirectory, collection.directory);
+    const collectionDirectory = path2.join(baseDirectory, collection.directory);
     const include = Array.isArray(collection.include) ? collection.include : [collection.include];
     const filePaths = await glob(include, {
       cwd: collectionDirectory,
@@ -355,135 +252,24 @@ function createCollector(emitter, baseDirectory = ".") {
   };
 }
 
-// src/writer.ts
-import fs2 from "fs/promises";
-import path4 from "path";
-import pluralize2 from "pluralize";
-
-// src/serializer.ts
-import z2 from "zod";
-import serializeJs from "serialize-javascript";
-var literalSchema = z2.union([
-  // json
-  z2.string(),
-  z2.number(),
-  z2.boolean(),
-  z2.null(),
-  // serializable-javascript
-  z2.undefined(),
-  z2.date(),
-  z2.map(z2.unknown(), z2.unknown()),
-  z2.set(z2.unknown()),
-  z2.bigint()
-]);
-var schema = z2.lazy(
-  () => z2.union([literalSchema, z2.array(schema), z2.record(schema)])
-);
-var extension = "js";
-var serializableSchema = z2.record(schema);
-function serialize(value) {
-  const serializedValue = serializeJs(value, {
-    space: 2,
-    unsafe: true,
-    ignoreFunction: true
-  });
-  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 = path4.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(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;
-  }
-  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(path4.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/synchronizer.ts
+import path3 from "node:path";
 import picomatch from "picomatch";
-import path5 from "path";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
   function findCollections(filePath) {
-    const resolvedFilePath = path5.resolve(filePath);
+    const resolvedFilePath = path3.resolve(filePath);
     return collections.filter((collection) => {
       return resolvedFilePath.startsWith(
-        path5.resolve(baseDirectory, collection.directory)
+        path3.resolve(baseDirectory, collection.directory)
       );
     });
   }
   function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = path5.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = path5.resolve(filePath);
+    const resolvedCollectionPath = path3.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path3.resolve(filePath);
     let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith(path5.sep)) {
-      relativePath = relativePath.slice(path5.sep.length);
+    if (relativePath.startsWith(path3.sep)) {
+      relativePath = relativePath.slice(path3.sep.length);
     }
     return relativePath;
   }
@@ -547,110 +333,43 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
   };
 }
 
-// src/cache.ts
-import path6, { join as join2 } 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 = path6.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 = join2(cacheDirectory, "mapping.json");
-  const mapping = await readMapping(mappingPath);
-  async function flush() {
-    await writeFile(mappingPath, JSON.stringify(mapping));
-  }
-  function cache(collection, file) {
-    const directory = join2(
-      cacheDirectory,
-      fileName(collection),
-      fileName(file)
-    );
-    let collectionMapping = mapping[collection];
-    if (!collectionMapping) {
-      collectionMapping = {};
-      mapping[collection] = collectionMapping;
-    }
-    let fileMapping = collectionMapping[file];
-    if (!fileMapping) {
-      fileMapping = [];
-      collectionMapping[file] = fileMapping;
-    }
-    let newFileMapping = [];
-    const cacheFn = async (input, fn) => {
-      const key = createKey(configChecksum, input);
-      newFileMapping.push(key);
-      const filePath = join2(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 = join2(directory, `${key}.cache`);
-        if (existsSync2(filePath)) {
-          await unlink(filePath);
-        }
-      }
-      if (collectionMapping) {
-        collectionMapping[file] = newFileMapping;
-      }
-    };
-    return {
-      cacheFn,
-      tidyUp
-    };
-  }
-  return {
-    cache,
-    flush
-  };
+// 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 serializeJs from "serialize-javascript";
+import z from "zod";
+var literalSchema = z.union([
+  // json
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  // serializable-javascript
+  z.undefined(),
+  z.date(),
+  z.map(z.unknown(), z.unknown()),
+  z.set(z.unknown()),
+  z.bigint()
+]);
+var schema = z.lazy(
+  () => z.union([literalSchema, z.array(schema), z.record(schema)])
+);
+var extension = "js";
+var serializableSchema = z.record(schema);
+function serialize(value) {
+  const serializedValue = serializeJs(value, {
+    space: 2,
+    unsafe: true,
+    ignoreFunction: true
+  });
+  return `export default ${serializedValue};`;
 }
 
 // src/transformer.ts
-import { basename, dirname as dirname3, extname } from "path";
-import { z as z3 } from "zod";
-import os from "os";
-import pLimit from "p-limit";
 var TransformError = class extends Error {
   type;
   constructor(type, message) {
@@ -658,8 +377,8 @@ var TransformError = class extends Error {
     this.type = type;
   }
 };
-function createPath(path8, ext) {
-  let p = path8.slice(0, -ext.length);
+function createPath(path9, ext) {
+  let p = path9.slice(0, -ext.length);
   if (p.endsWith("/index")) {
     p = p.slice(0, -6);
   }
@@ -669,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: path8 } = file;
+    const { data, path: path9 } = file;
     const schema2 = createSchema(collection.parser, collection.schema);
     let parsedData = await schema2.safeParseAsync(data);
     if (!parsedData.success) {
@@ -688,7 +407,7 @@ function createTransformer(emitter, cacheManager) {
       });
       return null;
     }
-    const ext = extname(path8);
+    const ext = extname(path9);
     let extension2 = ext;
     if (extension2.startsWith(".")) {
       extension2 = extension2.slice(1);
@@ -696,11 +415,11 @@ function createTransformer(emitter, cacheManager) {
     const document = {
       ...parsedData.data,
       _meta: {
-        filePath: path8,
-        fileName: basename(path8),
-        directory: dirname3(path8),
+        filePath: path9,
+        fileName: basename(path9),
+        directory: dirname(path9),
         extension: extension2,
-        path: createPath(path8, ext)
+        path: createPath(path9, ext)
       }
     };
     return {
@@ -740,9 +459,9 @@ function createTransformer(emitter, cacheManager) {
   }
   async function transformDocument(collections, collection, transform, doc) {
     const cache = cacheManager.cache(collection.name, doc.document._meta.path);
-    const context = createContext(collections, collection, cache);
+    const context2 = createContext(collections, collection, cache);
     try {
-      const document = await transform(doc.document, context);
+      const document = await transform(doc.document, context2);
       await cache.tidyUp();
       return {
         ...doc,
@@ -791,16 +510,95 @@ function createTransformer(emitter, cacheManager) {
     }
     return docs;
   }
-  return async (untransformedCollections) => {
-    const promises = untransformedCollections.map(
-      (collection) => parseCollection(collection)
-    );
-    const collections = await Promise.all(promises);
-    for (const collection of collections) {
-      const documents = await transformCollection(collections, collection);
-      collection.documents = await validateDocuments(collection, documents);
-    }
-    return collections;
+  return async (untransformedCollections) => {
+    const promises = untransformedCollections.map(
+      (collection) => parseCollection(collection)
+    );
+    const collections = await Promise.all(promises);
+    for (const collection of collections) {
+      const documents = await transformCollection(collections, collection);
+      collection.documents = await validateDocuments(collection, documents);
+    }
+    return collections;
+  };
+}
+
+// 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}";
+`;
+  }
+  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;
+  }
+  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 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)
   };
 }
 
@@ -833,7 +631,7 @@ async function createBuildContext({
     configuration
   };
 }
-async function build2({
+async function build({
   emitter,
   transform,
   resolved,
@@ -872,12 +670,386 @@ async function build2({
   });
 }
 
+// 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;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    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 result + buffer + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+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;
+    }
+    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
+          }
+        });
+        extendsFiles.push(...parentConfig.files);
+      }
+    }
+    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);
+    }
+    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 {
+    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}`
+      );
+    }
+  };
+}
+
+// src/events.ts
+import { EventEmitter } from "node:events";
+function isEventWithError(event) {
+  return typeof event === "object" && event !== null && "error" in event;
+}
+function createEmitter() {
+  const emitter = new EventEmitter();
+  function on(key, listener) {
+    emitter.on(key, listener);
+  }
+  function emit(key, event) {
+    emitter.emit(key, event);
+    if (isEventWithError(event)) {
+      emitter.emit("_error", {
+        ...event,
+        _event: key
+      });
+    }
+    emitter.emit("_all", {
+      ...event,
+      _event: key
+    });
+  }
+  return {
+    on,
+    emit
+  };
+}
+
+// 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;
+    }
+    for (const event of events) {
+      await sync(event.type, event.path);
+    }
+  };
+  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 {
+    unsubscribe: async () => {
+      if (!subscriptions || subscriptions.length === 0) {
+        return;
+      }
+      await Promise.all(
+        subscriptions.map((subscription) => subscription.unsubscribe())
+      );
+      emitter.emit("watcher:unsubscribed", {
+        paths
+      });
+      return;
+    }
+  };
+}
+
 // src/builder.ts
 function resolveOutputDir(baseDirectory, options) {
   if (options.outputDir) {
     return options.outputDir;
   }
-  return path7.join(baseDirectory, ".content-collections", "generated");
+  return path8.join(baseDirectory, ".content-collections", "generated");
 }
 var ConfigurationReloadError = class extends Error {
   constructor(message) {
@@ -888,7 +1060,7 @@ async function createBuilder(configurationPath, options = {
   configName: defaultConfigName
 }, emitter = createEmitter()) {
   const readConfiguration = createConfigurationReader();
-  const baseDirectory = path7.dirname(configurationPath);
+  const baseDirectory = path8.dirname(configurationPath);
   const outputDirectory = resolveOutputDir(baseDirectory, options);
   emitter.emit("builder:created", {
     createdAt: Date.now(),
@@ -897,7 +1069,7 @@ async function createBuilder(configurationPath, options = {
   });
   let configuration = await readConfiguration(configurationPath, options);
   let watcher2 = null;
-  let context = await createBuildContext({
+  let context2 = await createBuildContext({
     emitter,
     baseDirectory,
     outputDirectory,
@@ -910,7 +1082,7 @@ async function createBuilder(configurationPath, options = {
           filePath,
           modification
         });
-        await build2(context);
+        await build(context2);
         return true;
       }
     } else {
@@ -919,7 +1091,7 @@ async function createBuilder(configurationPath, options = {
           filePath,
           modification
         });
-        await build2(context);
+        await build(context2);
         return true;
       }
     }
@@ -940,7 +1112,7 @@ async function createBuilder(configurationPath, options = {
     if (watcher2) {
       await watcher2.unsubscribe();
     }
-    context = await createBuildContext({
+    context2 = await createBuildContext({
       emitter,
       baseDirectory,
       outputDirectory,
@@ -957,7 +1129,7 @@ async function createBuilder(configurationPath, options = {
     return true;
   }
   async function onFileChange(modification, filePath) {
-    const { synchronizer } = context;
+    const { synchronizer } = context2;
     if (modification === "delete") {
       return synchronizer.deleted(filePath);
     } else {
@@ -975,12 +1147,35 @@ async function createBuilder(configurationPath, options = {
     };
   }
   return {
-    build: () => build2(context),
+    build: () => build(context2),
     sync,
     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,