@content-collections/core 0.6.3 → 0.7.0

package/README.md

@@ -28,7 +28,7 @@ Content Collections offers a variety of adapters that seamlessly integrate with
 - [Qwik](https://www.content-collections.dev/docs/quickstart/qwik)
 - [Remix (Vite)](https://www.content-collections.dev/docs/quickstart/remix-vite)
 - [Solid Start](https://www.content-collections.dev/docs/quickstart/solid)
-- [Svelte Kit](https://www.content-collections.dev/docs/quickstart/svelte-kit)
+- [SvelteKit](https://www.content-collections.dev/docs/quickstart/svelte-kit)
 - [Vite](https://www.content-collections.dev/docs/quickstart/vite)
 
 If your framework is not listed, you can still use Content Collections by using the [CLI](https://www.content-collections.dev/docs/quickstart/cli). Please open a ticket if you want to see your framework listed.

package/dist/index.d.ts

@@ -14,7 +14,7 @@ declare const parsers: {
     };
     readonly json: {
         readonly hasContent: false;
-        readonly parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+        readonly parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
     };
     readonly yaml: {
         readonly hasContent: false;
@@ -54,12 +54,13 @@ type GetShape<TParser extends Parser | undefined, TShape extends ZodRawShape> =
 type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z$1.infer<ZodObject<GetShape<TParser, TShape>>> & {
     _meta: Meta;
 };
-type Context = {
+type Context<TSchema = unknown> = {
     documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
     cache: CacheFn;
     collection: {
         name: string;
         directory: string;
+        documents: () => Promise<Array<TSchema>>;
     };
 };
 type Z = typeof z$1;
@@ -68,7 +69,7 @@ type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser
     parser?: TParser;
     typeName?: string;
     schema: (z: Z) => TShape;
-    transform?: (data: TSchema, context: Context) => TTransformResult;
+    transform?: (data: TSchema, context: Context<TSchema>) => TTransformResult;
     directory: string;
     include: string | string[];
     exclude?: string | string[];
@@ -150,12 +151,31 @@ declare class TransformError extends Error {
 }
 
 type WatcherEvents = {
-    "watcher:file-changed": {
-        filePath: string;
-        modification: Modification;
+    "watcher:subscribe-error": {
+        paths: Array<string>;
+        error: Error;
+    };
+    "watcher:subscribed": {
+        paths: Array<string>;
     };
+    "watcher:unsubscribed": {
+        paths: Array<string>;
+    };
+};
+type SyncFn = (modification: Modification, path: string) => Promise<unknown>;
+type WatchableCollection = {
+    directory: string;
 };
+type WatcherConfiguration = {
+    inputPaths: Array<string>;
+    collections: Array<WatchableCollection>;
+};
+declare function createWatcher(emitter: Emitter, baseDirectory: string, configuration: WatcherConfiguration, sync: SyncFn): Promise<{
+    unsubscribe: () => Promise<void>;
+}>;
+type Watcher = Awaited<ReturnType<typeof createWatcher>>;
 
+type EventMap = Record<string, object>;
 type EventWithError = {
     error: Error;
 };
@@ -168,6 +188,16 @@ type SystemEvents = {
     _error: ErrorEvent;
     _all: SystemEvent;
 };
+type Keys<TEvents extends EventMap> = keyof TEvents & string;
+type Listener<TEvent> = (event: TEvent) => void;
+declare function createEmitter<TEvents extends EventMap>(): {
+    on: {
+        <TKey extends Keys<TEvents>>(key: TKey, listener: Listener<TEvents[TKey]>): void;
+        <TKey extends Keys<SystemEvents>>(key: TKey, listener: Listener<SystemEvents[TKey]>): void;
+    };
+    emit: <TKey extends Keys<TEvents>>(key: TKey, event: TEvents[TKey]) => void;
+};
+type Emitter = ReturnType<typeof createEmitter<Events>>;
 
 type ErrorType = "Read" | "Compile";
 declare class ConfigurationError extends Error {
@@ -179,29 +209,56 @@ type Options$1 = {
     cacheDir?: string;
 };
 
-type BuilderEvents = {
+type BuildEvents = {
     "builder:start": {
         startedAt: number;
     };
     "builder:end": {
         startedAt: number;
         endedAt: number;
+        stats: {
+            collections: number;
+            documents: number;
+        };
+    };
+};
+
+type BuilderEvents = BuildEvents & {
+    "builder:created": {
+        createdAt: number;
+        configurationPath: string;
+        outputDirectory: string;
+    };
+    "watcher:file-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+    "watcher:config-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+    "watcher:config-reload-error": {
+        error: Error;
+        configurationPath: string;
     };
 };
 type Options = Options$1 & {
     outputDir?: string;
 };
-declare function createBuilder(configurationPath: string, options?: Options): Promise<{
-    sync: (modification: Modification, filePath: string) => Promise<boolean>;
+declare class ConfigurationReloadError extends Error {
+    constructor(message: string);
+}
+declare function createBuilder(configurationPath: string, options?: Options, emitter?: Emitter): Promise<{
     build: () => Promise<void>;
+    sync: (modification: Modification, filePath: string) => Promise<boolean>;
     watch: () => Promise<{
         unsubscribe: () => Promise<void>;
     }>;
     on: {
-        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "watcher:file-changed">(key: TKey, listener: (event: Events[TKey]) => void): void;
-        <TKey_1 extends "_error" | "_all">(key: TKey_1, listener: (event: SystemEvents[TKey_1]) => void): void;
+        <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+        <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
     };
 }>;
 type Builder = Awaited<ReturnType<typeof createBuilder>>;
 
-export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, TransformError, createBuilder, defineCollection, defineConfig };
+export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, ConfigurationReloadError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, TransformError, type Watcher, createBuilder, defineCollection, defineConfig };

package/dist/index.js

@@ -14,6 +14,20 @@ function isDefined(value) {
 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`);
@@ -38,59 +52,81 @@ function defineConfig(config) {
 }
 
 // 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;
-  }
-};
+
+// 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 };
+      });
+    }
+  };
+}
 var importPathPlugin = {
   name: "import-path",
-  setup(build2) {
-    build2.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
-      return { path: path.join(__dirname, "index.ts"), external: true };
+  setup(build3) {
+    build3.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
+      return { path: join(__dirname, "index.ts"), external: true };
     });
   }
 };
-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");
-}
-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)
-  ];
+  const plugins = [createExternalsPlugin(configurationPath)];
   if (process.env.NODE_ENV === "test") {
     plugins.push(importPathPlugin);
   }
-  await esbuild.build({
+  const result = await build({
     entryPoints: [configurationPath],
     packages: "external",
     bundle: true,
     platform: "node",
     format: "esm",
     plugins,
-    outfile
+    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 path.join(path.dirname(config), ".content-collections", "cache");
 }
 function createConfigurationReader() {
   return async (configurationPath, options = {
@@ -106,30 +142,103 @@ function createConfigurationReader() {
     await fs.mkdir(cacheDir, { recursive: true });
     const outfile = path.join(cacheDir, options.configName);
     try {
-      await compile(configurationPath, outfile);
+      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}`
       );
     }
-    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,
-      generateTypes: true,
-      checksum
-    };
+  };
+}
+
+// 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;
+    }
+    for (const event of events) {
+      await sync(event.type, event.path);
+    }
+  };
+  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;
+      }
+      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
+    });
+  }
+  return {
+    on,
+    emit
   };
 }
 
 // src/collector.ts
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { readFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 
 // src/parser.ts
 import matter from "gray-matter";
@@ -187,7 +296,7 @@ function createCollector(emitter, baseDirectory = ".") {
     }
   }
   async function collectFile(collection, filePath) {
-    const absolutePath = path2.join(baseDirectory, collection.directory, filePath);
+    const absolutePath = path3.join(baseDirectory, collection.directory, filePath);
     const file = await read(absolutePath);
     if (!file) {
       return null;
@@ -200,7 +309,7 @@ function createCollector(emitter, baseDirectory = ".") {
       };
     } catch (error) {
       emitter.emit("collector:parse-error", {
-        filePath: path2.join(collection.directory, filePath),
+        filePath: path3.join(collection.directory, filePath),
         error: new CollectError("Parse", String(error))
       });
       return null;
@@ -217,8 +326,9 @@ function createCollector(emitter, baseDirectory = ".") {
     return void 0;
   }
   async function resolveCollection(collection) {
-    const collectionDirectory = path2.join(baseDirectory, collection.directory);
-    const filePaths = await fg(collection.include, {
+    const collectionDirectory = path3.join(baseDirectory, collection.directory);
+    const include = Array.isArray(collection.include) ? collection.include : [collection.include];
+    const filePaths = await glob(include, {
       cwd: collectionDirectory,
       onlyFiles: true,
       absolute: false,
@@ -247,7 +357,7 @@ function createCollector(emitter, baseDirectory = ".") {
 
 // src/writer.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import pluralize2 from "pluralize";
 
 // src/serializer.ts
@@ -286,7 +396,7 @@ function createArrayConstName(name) {
   return "all" + pluralize2(suffix);
 }
 async function createDataFile(directory, collection) {
-  const dataPath = path3.join(
+  const dataPath = path4.join(
     directory,
     `${createArrayConstName(collection.name)}.${extension}`
   );
@@ -313,11 +423,11 @@ async function createJavaScriptFile(directory, configuration) {
   }
   content += "\n";
   content += "export { " + collections.join(", ") + " };\n";
-  await fs2.writeFile(path3.join(directory, "index.js"), content, "utf-8");
+  await fs2.writeFile(path4.join(directory, "index.js"), content, "utf-8");
 }
 function createImportPath(directory, target) {
-  let importPath = path3.posix.join(
-    ...path3.relative(directory, target).split(path3.sep)
+  let importPath = path4.posix.join(
+    ...path4.relative(directory, target).split(path4.sep)
   );
   if (!importPath.startsWith(".")) {
     importPath = "./" + importPath;
@@ -345,7 +455,7 @@ import { GetTypeByName } from "@content-collections/core";
   }
   content += "\n";
   content += "export {};\n";
-  await fs2.writeFile(path3.join(directory, "index.d.ts"), content, "utf-8");
+  await fs2.writeFile(path4.join(directory, "index.d.ts"), content, "utf-8");
 }
 async function createWriter(directory) {
   await fs2.mkdir(directory, { recursive: true });
@@ -356,179 +466,28 @@ async function createWriter(directory) {
   };
 }
 
-// src/transformer.ts
-import { basename, dirname, extname } from "path";
-import { z as z3 } from "zod";
-var TransformError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-function createPath(path7, ext) {
-  let p = path7.slice(0, -ext.length);
-  if (p.endsWith("/index")) {
-    p = p.slice(0, -6);
-  }
-  return p;
-}
-function createTransformer(emitter, cacheManager) {
-  function createSchema(parserName, schema2) {
-    const parser = parsers[parserName];
-    if (!parser.hasContent) {
-      return z3.object(schema2);
-    }
-    return z3.object({
-      content: z3.string(),
-      ...schema2
-    });
-  }
-  async function parseFile(collection, file) {
-    const { data, path: path7 } = file;
-    const schema2 = createSchema(collection.parser, collection.schema);
-    let parsedData = await schema2.safeParseAsync(data);
-    if (!parsedData.success) {
-      emitter.emit("transformer:validation-error", {
-        collection,
-        file,
-        error: new TransformError("Validation", parsedData.error.message)
-      });
-      return null;
-    }
-    const ext = extname(path7);
-    let extension2 = ext;
-    if (extension2.startsWith(".")) {
-      extension2 = extension2.slice(1);
-    }
-    const document = {
-      ...parsedData.data,
-      _meta: {
-        filePath: path7,
-        fileName: basename(path7),
-        directory: dirname(path7),
-        extension: extension2,
-        path: createPath(path7, ext)
-      }
-    };
-    return {
-      document
-    };
-  }
-  async function parseCollection(collection) {
-    const promises = collection.files.map(
-      (file) => parseFile(collection, file)
-    );
-    return {
-      ...collection,
-      documents: (await Promise.all(promises)).filter(isDefined)
-    };
-  }
-  function createContext(collections, collection, cache) {
-    return {
-      documents: (collection2) => {
-        const resolved = collections.find((c) => c.name === collection2.name);
-        if (!resolved) {
-          throw new TransformError(
-            "Configuration",
-            `Collection ${collection2.name} not found, do you have registered it in your configuration?`
-          );
-        }
-        return resolved.documents.map((doc) => doc.document);
-      },
-      collection: {
-        name: collection.name,
-        directory: collection.directory
-      },
-      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))
-            });
-          }
-        }
-      }
-      await cacheManager.flush();
-      return docs;
-    }
-    return collection.documents;
-  }
-  async function validateDocuments(collection, documents) {
-    const docs = [];
-    for (const doc of documents) {
-      let parsedData = await serializableSchema.safeParseAsync(doc.document);
-      if (parsedData.success) {
-        docs.push(doc);
-      } else {
-        emitter.emit("transformer:result-error", {
-          collection,
-          document: doc.document,
-          error: new TransformError("Result", parsedData.error.message)
-        });
-      }
-    }
-    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;
-  };
-}
-
 // src/synchronizer.ts
-import micromatch from "micromatch";
-import path4 from "path";
+import picomatch from "picomatch";
+import path5 from "path";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
   function findCollections(filePath) {
-    const resolvedFilePath = path4.resolve(filePath);
+    const resolvedFilePath = path5.resolve(filePath);
     return collections.filter((collection) => {
       return resolvedFilePath.startsWith(
-        path4.resolve(baseDirectory, collection.directory)
+        path5.resolve(baseDirectory, collection.directory)
       );
     });
   }
   function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = path4.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = path4.resolve(filePath);
+    const resolvedCollectionPath = path5.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path5.resolve(filePath);
     let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith("/")) {
-      relativePath = relativePath.slice(1);
+    if (relativePath.startsWith(path5.sep)) {
+      relativePath = relativePath.slice(path5.sep.length);
     }
     return relativePath;
   }
-  function resolve(filePath) {
+  function resolve2(filePath) {
     const collections2 = findCollections(filePath);
     return collections2.map((collection) => {
       const relativePath = createRelativePath(collection.directory, filePath);
@@ -537,13 +496,13 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
         relativePath
       };
     }).filter(({ collection, relativePath }) => {
-      return micromatch.isMatch(relativePath, collection.include, {
+      return picomatch.isMatch(relativePath, collection.include, {
         ignore: collection.exclude
       });
     });
   }
   function deleted(filePath) {
-    const resolvedCollections = resolve(filePath);
+    const resolvedCollections = resolve2(filePath);
     if (resolvedCollections.length === 0) {
       return false;
     }
@@ -560,7 +519,7 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
     return changed2;
   }
   async function changed(filePath) {
-    const resolvedCollections = resolve(filePath);
+    const resolvedCollections = resolve2(filePath);
     if (resolvedCollections.length === 0) {
       return false;
     }
@@ -588,75 +547,8 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
   };
 }
 
-// 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;
-    }
-    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
-        });
-        rebuild = true;
-      }
-    }
-    if (rebuild) {
-      await build2();
-    }
-  };
-  const subscriptions = await Promise.all(
-    paths.map((path7) => watcher.subscribe(path7, onChange))
-  );
-  return {
-    unsubscribe: async () => {
-      await Promise.all(
-        subscriptions.map((subscription) => subscription.unsubscribe())
-      );
-      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
-    });
-  }
-  return {
-    on,
-    emit
-  };
-}
-
 // src/cache.ts
-import path5, { join } from "path";
+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";
@@ -664,7 +556,7 @@ 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");
+  const cacheDirectory = path6.join(directory, ".content-collections", "cache");
   if (!existsSync2(cacheDirectory)) {
     await mkdir(cacheDirectory, { recursive: true });
   }
@@ -687,13 +579,13 @@ async function readMapping(mappingPath) {
 }
 async function createCacheManager(baseDirectory, configChecksum) {
   const cacheDirectory = await createCacheDirectory(baseDirectory);
-  const mappingPath = join(cacheDirectory, "mapping.json");
+  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 = join(
+    const directory = join2(
       cacheDirectory,
       fileName(collection),
       fileName(file)
@@ -712,7 +604,7 @@ async function createCacheManager(baseDirectory, configChecksum) {
     const cacheFn = async (input, fn) => {
       const key = createKey(configChecksum, input);
       newFileMapping.push(key);
-      const filePath = join(directory, `${key}.cache`);
+      const filePath = join2(directory, `${key}.cache`);
       if (fileMapping?.includes(key) || newFileMapping.includes(key)) {
         if (existsSync2(filePath)) {
           try {
@@ -734,7 +626,7 @@ async function createCacheManager(baseDirectory, configChecksum) {
     const tidyUp = async () => {
       const filesToDelete = fileMapping?.filter((key) => !newFileMapping.includes(key)) || [];
       for (const key of filesToDelete) {
-        const filePath = join(directory, `${key}.cache`);
+        const filePath = join2(directory, `${key}.cache`);
         if (existsSync2(filePath)) {
           await unlink(filePath);
         }
@@ -754,67 +646,337 @@ async function createCacheManager(baseDirectory, configChecksum) {
   };
 }
 
-// src/builder.ts
-function resolveOutputDir(baseDirectory, options) {
-  if (options.outputDir) {
-    return options.outputDir;
+// 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) {
+    super(message);
+    this.type = type;
   }
-  return path6.join(baseDirectory, ".content-collections", "generated");
+};
+function createPath(path8, ext) {
+  let p = path8.slice(0, -ext.length);
+  if (p.endsWith("/index")) {
+    p = p.slice(0, -6);
+  }
+  return p;
 }
-async function createBuilder(configurationPath, options = {
-  configName: defaultConfigName
+function createTransformer(emitter, cacheManager) {
+  function createSchema(parserName, schema2) {
+    const parser = parsers[parserName];
+    if (!parser.hasContent) {
+      return z3.object(schema2);
+    }
+    return z3.object({
+      content: z3.string(),
+      ...schema2
+    });
+  }
+  async function parseFile(collection, file) {
+    const { data, path: path8 } = file;
+    const schema2 = createSchema(collection.parser, collection.schema);
+    let parsedData = await schema2.safeParseAsync(data);
+    if (!parsedData.success) {
+      emitter.emit("transformer:validation-error", {
+        collection,
+        file,
+        error: new TransformError("Validation", parsedData.error.message)
+      });
+      return null;
+    }
+    const ext = extname(path8);
+    let extension2 = ext;
+    if (extension2.startsWith(".")) {
+      extension2 = extension2.slice(1);
+    }
+    const document = {
+      ...parsedData.data,
+      _meta: {
+        filePath: path8,
+        fileName: basename(path8),
+        directory: dirname3(path8),
+        extension: extension2,
+        path: createPath(path8, ext)
+      }
+    };
+    return {
+      document
+    };
+  }
+  async function parseCollection(collection) {
+    const promises = collection.files.map(
+      (file) => parseFile(collection, file)
+    );
+    return {
+      ...collection,
+      documents: (await Promise.all(promises)).filter(isDefined)
+    };
+  }
+  function createContext(collections, collection, cache) {
+    return {
+      documents: (collection2) => {
+        const resolved = collections.find((c) => c.name === collection2.name);
+        if (!resolved) {
+          throw new TransformError(
+            "Configuration",
+            `Collection ${collection2.name} not found, do you have registered it in your configuration?`
+          );
+        }
+        return resolved.documents.map((doc) => doc.document);
+      },
+      collection: {
+        name: collection.name,
+        directory: collection.directory,
+        documents: async () => {
+          return collection.documents.map((doc) => doc.document);
+        }
+      },
+      cache: cache.cacheFn
+    };
+  }
+  async function transformDocument(collections, collection, transform, doc) {
+    const cache = cacheManager.cache(collection.name, doc.document._meta.path);
+    const context = createContext(collections, collection, cache);
+    try {
+      const document = await transform(doc.document, context);
+      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 transformed.filter(isDefined);
+    }
+    return collection.documents;
+  }
+  async function validateDocuments(collection, documents) {
+    const docs = [];
+    for (const doc of documents) {
+      let parsedData = await serializableSchema.safeParseAsync(doc.document);
+      if (parsedData.success) {
+        docs.push(doc);
+      } else {
+        emitter.emit("transformer:result-error", {
+          collection,
+          document: doc.document,
+          error: new TransformError("Result", parsedData.error.message)
+        });
+      }
+    }
+    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;
+  };
+}
+
+// src/build.ts
+async function createBuildContext({
+  emitter,
+  outputDirectory,
+  baseDirectory,
+  configuration
 }) {
-  const 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([
+  const [writer, resolved, cacheManager] = await Promise.all([
+    createWriter(outputDirectory),
     collector.collect(configuration.collections),
-    writer.createJavaScriptFile(configuration),
-    writer.createTypeDefinitionFile(configuration)
+    createCacheManager(baseDirectory, configuration.checksum)
   ]);
   const synchronizer = createSynchronizer(
     collector.collectFile,
     resolved,
     baseDirectory
   );
-  const cacheManager = await createCacheManager(baseDirectory, configuration.checksum);
   const transform = createTransformer(emitter, cacheManager);
+  return {
+    resolved,
+    writer,
+    synchronizer,
+    transform,
+    emitter,
+    cacheManager,
+    configuration
+  };
+}
+async function build2({
+  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
+    }
+  );
+  emitter.emit("builder:end", {
+    startedAt,
+    endedAt: Date.now(),
+    stats
+  });
+}
+
+// src/builder.ts
+function resolveOutputDir(baseDirectory, options) {
+  if (options.outputDir) {
+    return options.outputDir;
+  }
+  return path7.join(baseDirectory, ".content-collections", "generated");
+}
+var ConfigurationReloadError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+async function createBuilder(configurationPath, options = {
+  configName: defaultConfigName
+}, emitter = createEmitter()) {
+  const readConfiguration = createConfigurationReader();
+  const baseDirectory = path7.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 context = 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 build2(context);
+        return true;
+      }
+    } else {
+      if (await onFileChange(modification, filePath)) {
+        emitter.emit("watcher:file-changed", {
+          filePath,
+          modification
+        });
+        await build2(context);
+        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();
+    }
+    context = await createBuildContext({
+      emitter,
+      baseDirectory,
+      outputDirectory,
+      configuration
     });
+    if (watcher2) {
+      watcher2 = await createWatcher(
+        emitter,
+        baseDirectory,
+        configuration,
+        sync
+      );
+    }
+    return true;
+  }
+  async function onFileChange(modification, filePath) {
+    const { synchronizer } = context;
+    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: () => build2(context),
     sync,
-    build: build2,
     watch,
     on: emitter.on
   };
@@ -822,6 +984,7 @@ async function createBuilder(configurationPath, options = {
 export {
   CollectError,
   ConfigurationError,
+  ConfigurationReloadError,
   TransformError,
   createBuilder,
   defineCollection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-collections/core",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,27 +19,29 @@
     "typescript": "^5.0.2"
   },
   "devDependencies": {
-    "@types/micromatch": "^4.0.7",
     "@types/node": "^20.14.9",
+    "@types/picomatch": "^3.0.1",
     "@types/pluralize": "^0.0.33",
     "@types/serialize-javascript": "^5.0.4",
-    "@vitest/coverage-v8": "^1.5.0",
+    "@vitest/coverage-v8": "^2.0.5",
     "tsup": "^8.0.2",
     "tsx": "^4.1.1",
-    "typescript": "^5.4.5",
-    "vitest": "^1.5.0"
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",
+    "bundle-require": "^5.0.0",
     "camelcase": "^8.0.0",
     "esbuild": "^0.21.4",
-    "fast-glob": "^3.3.2",
     "gray-matter": "^4.0.3",
-    "micromatch": "^4.0.7",
+    "p-limit": "^6.1.0",
+    "picomatch": "^4.0.2",
     "pluralize": "^8.0.0",
     "serialize-javascript": "^6.0.2",
+    "tinyglobby": "^0.2.5",
     "yaml": "^2.4.5",
-    "zod": "^3.22.5"
+    "zod": "^3.23.8"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts -d dist",