@content-collections/core 0.2.0 → 0.3.0

package/dist/apidoc.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodRawShape } from 'zod';
+import { ZodString } from 'zod';
+import { ZodTypeAny } from 'zod';
+
+declare type AddContent<TShape extends ZodRawShape> = TShape extends {
+    content: ZodTypeAny;
+} ? TShape : TShape & WithContent;
+
+export declare type AnyCollection = Collection<any, ZodRawShape, any, any, any>;
+
+export declare type AnyConfiguration = Configuration<Array<AnyCollection>>;
+
+export declare type Builder = Awaited<ReturnType<typeof createBuilder>>;
+
+export declare type BuilderEvents = {
+    "builder:start": {
+        startedAt: number;
+    };
+    "builder:end": {
+        startedAt: number;
+        endedAt: number;
+    };
+};
+
+export declare class CollectError extends Error {
+    type: ErrorType$2;
+    constructor(type: ErrorType$2, message: string);
+}
+
+export declare type Collection<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>, "schema"> & {
+    typeName: string;
+    schema: TShape;
+};
+
+declare type CollectionByName<TConfiguration extends AnyConfiguration> = {
+    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
+};
+
+declare type CollectionFile = {
+    data: {
+        content: string;
+        [key: string]: unknown;
+    };
+    path: string;
+};
+
+export declare type CollectionRequest<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = {
+    /**
+     * The name of the collection
+     */
+    name: TName;
+    /**
+     * The name of the generated TypeScript type.
+     * If the typeName is undefined the pluralized name of the collection will be used.
+     */
+    typeName?: string;
+    schema: (z: Z) => TShape;
+    transform?: (context: Context, data: TSchema) => TTransformResult;
+    directory: string | string[];
+    include: string | string[];
+    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
+};
+
+declare type CollectorEvents = {
+    "collector:read-error": {
+        filePath: string;
+        error: CollectError;
+    };
+    "collector:parse-error": {
+        filePath: string;
+        error: CollectError;
+    };
+};
+
+export declare type Configuration<TCollections extends Array<AnyCollection>> = {
+    collections: TCollections;
+};
+
+export declare class ConfigurationError extends Error {
+    type: ErrorType;
+    constructor(type: ErrorType, message: string);
+}
+
+export declare type Context = {
+    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["schema"]>>;
+};
+
+export declare function createBuilder(configurationPath: string, options?: Options): Promise<{
+    sync: (modification: Modification, filePath: string) => Promise<boolean>;
+    build: () => Promise<void>;
+    watch: () => Promise<{
+        unsubscribe: () => Promise<void>;
+    }>;
+    on: {
+        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-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;
+    };
+}>;
+
+export declare function defineCollection<TName extends string, TShape extends ZodRawShape, TSchema = Schema<TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TSchema, TTransformResult, TDocument>;
+
+export declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
+
+declare type ErrorEvent = EventWithError & SystemEvent;
+
+declare type ErrorType$1 = "Validation" | "Configuration" | "Transform";
+
+declare type ErrorType$2 = "Parse" | "Read";
+
+declare type ErrorType = "Read" | "Compile";
+
+declare type Events = BuilderEvents & CollectorEvents & TransformerEvents & WatcherEvents;
+
+declare type EventWithError = {
+    error: Error;
+};
+
+declare type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, infer TDocument> ? TDocument : never;
+
+export declare type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
+
+export declare type Meta = {
+    filePath: string;
+    fileName: string;
+    directory: string;
+    path: string;
+    extension: string;
+};
+
+export declare type Modification = "create" | "update" | "delete";
+
+declare type Options$1 = {
+    configName: string;
+    cacheDir?: string;
+};
+
+declare type Options = Options$1 & {
+    outputDir?: string;
+};
+
+export declare type Schema<TShape extends ZodRawShape> = z.infer<ZodObject<AddContent<TShape>>> & {
+    _meta: Meta;
+};
+
+declare type SystemEvent = {
+    _event: string;
+};
+
+declare type SystemEvents = {
+    _error: ErrorEvent;
+    _all: SystemEvent;
+};
+
+declare type TransformerEvents = {
+    "transformer:validation-error": {
+        collection: AnyCollection;
+        file: CollectionFile;
+        error: TransformError;
+    };
+    "transformer:error": {
+        collection: AnyCollection;
+        error: TransformError;
+    };
+};
+
+export declare class TransformError extends Error {
+    type: ErrorType$1;
+    constructor(type: ErrorType$1, message: string);
+}
+
+declare type WatcherEvents = {
+    "watcher:file-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+};
+
+declare type WithContent = {
+    content: ZodString;
+};
+
+declare type Z = typeof z;
+
+export { }

package/dist/index.d.ts

@@ -1,4 +1,27 @@
 import { ZodRawShape, z, ZodObject, ZodTypeAny, ZodString } from 'zod';
+import { parse } from 'yaml';
+
+type Parsers = typeof parsers;
+type Parser = keyof typeof parsers;
+declare function frontmatterParser(fileContent: string): {
+    content: string;
+};
+declare const parsers: {
+    readonly frontmatter: {
+        readonly hasContent: true;
+        readonly parse: typeof frontmatterParser;
+    };
+    readonly json: {
+        readonly hasContent: false;
+        readonly parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+    };
+    readonly yaml: {
+        readonly hasContent: false;
+        readonly parse: typeof parse;
+    };
+};
+
+type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
 
 type Meta = {
     filePath: string;
@@ -13,30 +36,37 @@ type WithContent = {
 type AddContent<TShape extends ZodRawShape> = TShape extends {
     content: ZodTypeAny;
 } ? TShape : TShape & WithContent;
-type Schema<TShape extends ZodRawShape> = z.infer<ZodObject<AddContent<TShape>>> & {
+type GetParsedShape<TParser extends Parser, TShape extends ZodRawShape> = Parsers[TParser]["hasContent"] extends true ? AddContent<TShape> : TShape;
+type GetShape<TParser extends Parser | undefined, TShape extends ZodRawShape> = TParser extends Parser ? GetParsedShape<TParser, TShape> : AddContent<TShape>;
+type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z.infer<ZodObject<GetShape<TParser, TShape>>> & {
     _meta: Meta;
 };
 type Context = {
-    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["schema"]>>;
+    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
+    cache: CacheFn;
 };
 type Z = typeof z;
-type CollectionRequest<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = {
+type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser, TSchema, TTransformResult, TDocument> = {
     name: TName;
+    parser?: TParser;
     typeName?: string;
     schema: (z: Z) => TShape;
-    transform?: (context: Context, data: TSchema) => TTransformResult;
-    directory: string | string[];
+    transform?: (data: TSchema, context: Context) => TTransformResult;
+    directory: string;
     include: string | string[];
     onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
 };
-type Collection<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>, "schema"> & {
+type Collection<TName extends string, TShape extends ZodRawShape, TParser extends Parser, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>, "schema"> & {
     typeName: string;
     schema: TShape;
+    parser: TParser;
 };
-type AnyCollection = Collection<any, ZodRawShape, any, any, any>;
-declare function defineCollection<TName extends string, TShape extends ZodRawShape, TSchema = Schema<TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TSchema, TTransformResult, TDocument>;
+type AnyCollection = Collection<any, ZodRawShape, Parser, any, any, any>;
+declare function defineCollection<TName extends string, TShape extends ZodRawShape, TParser extends Parser = "frontmatter", TSchema = Schema<TParser, TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TParser, TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TParser, TSchema, TTransformResult, TDocument>;
+type Cache = "memory" | "file" | "none";
 type Configuration<TCollections extends Array<AnyCollection>> = {
     collections: TCollections;
+    cache?: Cache;
 };
 type AnyConfiguration = Configuration<Array<AnyCollection>>;
 declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
@@ -44,7 +74,7 @@ declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig)
 type Modification = "create" | "update" | "delete";
 type CollectionFile = {
     data: {
-        content: string;
+        content?: string;
         [key: string]: unknown;
     };
     path: string;
@@ -52,7 +82,7 @@ type CollectionFile = {
 type CollectionByName<TConfiguration extends AnyConfiguration> = {
     [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
 };
-type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, infer TDocument> ? TDocument : never;
+type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, any, infer TDocument> ? TDocument : never;
 type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
 
 type CollectorEvents = {

package/dist/index.js

@@ -21,9 +21,14 @@ function defineCollection(collection) {
   if (!typeName) {
     typeName = generateTypeName(collection.name);
   }
+  let parser = collection.parser;
+  if (!parser) {
+    parser = "frontmatter";
+  }
   return {
     ...collection,
     typeName,
+    parser,
     schema: collection.schema(z)
   };
 }
@@ -39,7 +44,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "@content-collections/core",
-  version: "0.1.2",
+  version: "0.3.0",
   type: "module",
   main: "dist/index.cjs",
   types: "./dist/index.d.ts",
@@ -79,12 +84,14 @@ var package_default = {
     "gray-matter": "^4.0.3",
     micromatch: "^4.0.5",
     pluralize: "^8.0.0",
+    yaml: "^2.3.4",
     zod: "^3.22.4"
   }
 };
 
 // src/configurationReader.ts
 import { existsSync } from "fs";
+import { createHash } from "crypto";
 var ConfigurationError = class extends Error {
   type;
   constructor(type, message) {
@@ -114,7 +121,10 @@ async function compile(configurationPath, outfile) {
   }
   await esbuild.build({
     entryPoints: [configurationPath],
-    external: [...Object.keys(package_default.dependencies), "@content-collections/*"],
+    external: [
+      ...Object.keys(package_default.dependencies),
+      "@content-collections/*"
+    ],
     bundle: true,
     platform: "node",
     format: "esm",
@@ -144,19 +154,56 @@ function createConfigurationReader() {
       );
     }
     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
+      generateTypes: true,
+      checksum
     };
   };
 }
 
 // src/collector.ts
-import matter from "gray-matter";
 import fg from "fast-glob";
 import { readFile } from "fs/promises";
 import path2 from "path";
+
+// src/parser.ts
+import matter from "gray-matter";
+import { parse, stringify } from "yaml";
+function frontmatterParser(fileContent) {
+  const { data, content } = matter(fileContent, {
+    engines: {
+      yaml: {
+        parse,
+        stringify
+      }
+    }
+  });
+  return {
+    ...data,
+    content: content.trim()
+  };
+}
+var parsers = {
+  frontmatter: {
+    hasContent: true,
+    parse: frontmatterParser
+  },
+  json: {
+    hasContent: false,
+    parse: JSON.parse
+  },
+  yaml: {
+    hasContent: false,
+    parse
+  }
+};
+
+// src/collector.ts
 var CollectError = class extends Error {
   type;
   constructor(type, message) {
@@ -176,55 +223,37 @@ function createCollector(emitter, baseDirectory = ".") {
       return null;
     }
   }
-  function parse(file) {
-    const { data, content } = matter(file);
-    return {
-      ...data,
-      content
-    };
-  }
-  async function collectFile(directory, filePath) {
-    const file = await read(path2.join(directory, filePath));
+  async function collectFile(collection, filePath) {
+    const absolutePath = path2.join(baseDirectory, collection.directory, filePath);
+    const file = await read(absolutePath);
     if (!file) {
       return null;
     }
     try {
-      const data = parse(file);
+      const data = parsers[collection.parser].parse(file);
       return {
         data,
         path: filePath
       };
     } catch (error) {
       emitter.emit("collector:parse-error", {
-        filePath: path2.join(directory, filePath),
+        filePath: path2.join(collection.directory, filePath),
         error: new CollectError("Parse", String(error))
       });
       return null;
     }
   }
-  async function resolveDirectory(collection, directory) {
-    const collectionDirectory = path2.join(baseDirectory, directory);
+  async function resolveCollection(collection) {
+    const collectionDirectory = path2.join(baseDirectory, collection.directory);
     const filePaths = await fg(collection.include, {
       cwd: collectionDirectory,
       onlyFiles: true,
       absolute: false
     });
     const promises = filePaths.map(
-      (filePath) => collectFile(collectionDirectory, filePath)
+      (filePath) => collectFile(collection, filePath)
     );
-    return Promise.all(promises);
-  }
-  async function resolveCollection(collection) {
-    let files = [];
-    if (typeof collection.directory === "string") {
-      files = await resolveDirectory(collection, collection.directory);
-    } else {
-      const promises = collection.directory.map(
-        (directory) => resolveDirectory(collection, directory)
-      );
-      const resolved = await Promise.all(promises);
-      files = resolved.flat();
-    }
+    const files = await Promise.all(promises);
     return {
       ...collection,
       files: files.filter(isDefined).sort(orderByPath)
@@ -326,23 +355,27 @@ var TransformError = class extends Error {
     this.type = type;
   }
 };
-function createPath(path6, ext) {
-  let p = path6.slice(0, -ext.length);
+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) {
-  function createSchema(schema) {
+function createTransformer(emitter, cacheManager) {
+  function createSchema(parserName, schema) {
+    const parser = parsers[parserName];
+    if (!parser.hasContent) {
+      return z2.object(schema);
+    }
     return z2.object({
       content: z2.string(),
       ...schema
     });
   }
   async function parseFile(collection, file) {
-    const { data, path: path6 } = file;
-    const schema = createSchema(collection.schema);
+    const { data, path: path7 } = file;
+    const schema = createSchema(collection.parser, collection.schema);
     let parsedData = await schema.safeParseAsync(data);
     if (!parsedData.success) {
       emitter.emit("transformer:validation-error", {
@@ -352,7 +385,7 @@ function createTransformer(emitter) {
       });
       return null;
     }
-    const ext = extname(path6);
+    const ext = extname(path7);
     let extension = ext;
     if (extension.startsWith(".")) {
       extension = extension.slice(1);
@@ -360,11 +393,11 @@ function createTransformer(emitter) {
     const document = {
       ...parsedData.data,
       _meta: {
-        filePath: path6,
-        fileName: basename(path6),
-        directory: dirname(path6),
+        filePath: path7,
+        fileName: basename(path7),
+        directory: dirname(path7),
         extension,
-        path: createPath(path6, ext)
+        path: createPath(path7, ext)
       }
     };
     return {
@@ -380,7 +413,7 @@ function createTransformer(emitter) {
       documents: (await Promise.all(promises)).filter(isDefined)
     };
   }
-  function createContext(collections) {
+  function createContext(collections, cache) {
     return {
       documents: (collection) => {
         const resolved = collections.find((c) => c.name === collection.name);
@@ -391,19 +424,22 @@ function createTransformer(emitter) {
           );
         }
         return resolved.documents.map((doc) => doc.document);
-      }
+      },
+      cache: cache.cacheFn
     };
   }
   async function transformCollection(collections, collection) {
     if (collection.transform) {
       const docs = [];
-      const context = createContext(collections);
       for (const doc of collection.documents) {
+        const cache = cacheManager.cache(collection.name, doc.document._meta.path);
+        const context = createContext(collections, cache);
         try {
           docs.push({
             ...doc,
-            document: await collection.transform(context, doc.document)
+            document: await collection.transform(doc.document, context)
           });
+          await cache.tidyUp();
         } catch (error) {
           if (error instanceof TransformError) {
             emitter.emit("transformer:error", {
@@ -418,6 +454,7 @@ function createTransformer(emitter) {
           }
         }
       }
+      await cacheManager.flush();
       return docs;
     }
     return collection.documents;
@@ -438,26 +475,13 @@ function createTransformer(emitter) {
 import micromatch from "micromatch";
 import path4 from "path";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollectionAndDirectory(filePath) {
+  function findCollection(filePath) {
     const resolvedFilePath = path4.resolve(filePath);
-    for (const collection of collections) {
-      const directories = [];
-      if (typeof collection.directory === "string") {
-        directories.push(collection.directory);
-      } else {
-        directories.push(...collection.directory);
-      }
-      for (const directory of directories) {
-        const resolvedDirectory = path4.resolve(baseDirectory, directory);
-        if (resolvedFilePath.startsWith(resolvedDirectory)) {
-          return {
-            collection,
-            directory
-          };
-        }
-      }
-    }
-    return null;
+    return collections.find((collection) => {
+      return resolvedFilePath.startsWith(
+        path4.resolve(baseDirectory, collection.directory)
+      );
+    });
   }
   function createRelativePath(collectionPath, filePath) {
     const resolvedCollectionPath = path4.resolve(baseDirectory, collectionPath);
@@ -469,12 +493,11 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
     return relativePath;
   }
   function resolve(filePath) {
-    const collectionAndDirectory = findCollectionAndDirectory(filePath);
-    if (!collectionAndDirectory) {
+    const collection = findCollection(filePath);
+    if (!collection) {
       return null;
     }
-    const { collection, directory } = collectionAndDirectory;
-    const relativePath = createRelativePath(directory, filePath);
+    const relativePath = createRelativePath(collection.directory, filePath);
     if (!micromatch.isMatch(relativePath, collection.include)) {
       return null;
     }
@@ -504,22 +527,7 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
     const index = collection.files.findIndex(
       (file2) => file2.path === relativePath
     );
-    const directories = [];
-    if (typeof collection.directory === "string") {
-      directories.push(collection.directory);
-    } else {
-      directories.push(...collection.directory);
-    }
-    let file = null;
-    for (const directory of directories) {
-      file = await readCollectionFile(
-        path4.join(baseDirectory, directory),
-        relativePath
-      );
-      if (file) {
-        break;
-      }
-    }
+    const file = await readCollectionFile(collection, relativePath);
     if (!file) {
       return false;
     }
@@ -538,7 +546,7 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
 }
 
 // src/builder.ts
-import path5 from "path";
+import path6 from "path";
 
 // src/watcher.ts
 import * as watcher from "@parcel/watcher";
@@ -563,7 +571,7 @@ async function createWatcher(emitter, paths, sync, build2) {
     }
   };
   const subscriptions = await Promise.all(
-    paths.map((path6) => watcher.subscribe(path6, onChange))
+    paths.map((path7) => watcher.subscribe(path7, onChange))
   );
   return {
     unsubscribe: async () => {
@@ -604,12 +612,96 @@ 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 createCacheManager(baseDirectory, configChecksum) {
+  const cacheDirectory = await createCacheDirectory(baseDirectory);
+  let mapping = {};
+  const mappingPath = join(cacheDirectory, "mapping.json");
+  if (existsSync2(mappingPath)) {
+    mapping = JSON.parse(await readFile2(mappingPath, "utf-8"));
+  }
+  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;
+    }
+    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 = join(directory, `${key}.cache`);
+      if (fileMapping?.includes(key) || newFileMapping.includes(key)) {
+        if (existsSync2(filePath)) {
+          return JSON.parse(await readFile2(filePath, "utf-8"));
+        }
+      }
+      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
+    };
+  }
+  return {
+    cache,
+    flush
+  };
+}
+
 // src/builder.ts
 function resolveOutputDir(baseDirectory, options) {
   if (options.outputDir) {
     return options.outputDir;
   }
-  return path5.join(baseDirectory, ".content-collections", "generated");
+  return path6.join(baseDirectory, ".content-collections", "generated");
 }
 async function createBuilder(configurationPath, options = {
   configName: defaultConfigName
@@ -617,7 +709,7 @@ async function createBuilder(configurationPath, options = {
   const emitter = createEmitter();
   const readConfiguration = createConfigurationReader();
   const configuration = await readConfiguration(configurationPath, options);
-  const baseDirectory = path5.dirname(configurationPath);
+  const baseDirectory = path6.dirname(configurationPath);
   const directory = resolveOutputDir(baseDirectory, options);
   const collector = createCollector(emitter, baseDirectory);
   const writer = await createWriter(directory);
@@ -631,7 +723,8 @@ async function createBuilder(configurationPath, options = {
     resolved,
     baseDirectory
   );
-  const transform = createTransformer(emitter);
+  const cacheManager = await createCacheManager(baseDirectory, configuration.checksum);
+  const transform = createTransformer(emitter, cacheManager);
   async function sync(modification, filePath) {
     if (modification === "delete") {
       return synchronizer.deleted(filePath);
@@ -655,16 +748,9 @@ async function createBuilder(configurationPath, options = {
     });
   }
   async function watch() {
-    const paths = [];
-    for (const collection of resolved) {
-      if (typeof collection.directory === "string") {
-        paths.push(path5.join(baseDirectory, collection.directory));
-      } else {
-        paths.push(
-          ...collection.directory.map((dir) => path5.join(baseDirectory, dir))
-        );
-      }
-    }
+    const paths = resolved.map(
+      (collection) => path6.join(baseDirectory, collection.directory)
+    );
     const watcher2 = await createWatcher(emitter, paths, sync, build2);
     return watcher2;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-collections/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.cjs",
   "types": "./dist/index.d.ts",
@@ -33,6 +33,7 @@
     "gray-matter": "^4.0.3",
     "micromatch": "^4.0.5",
     "pluralize": "^8.0.0",
+    "yaml": "^2.3.4",
     "zod": "^3.22.4"
   },
   "scripts": {