@content-collections/core 0.2.0 → 0.3.1

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,9 +44,9 @@ import path from "path";
 // package.json
 var package_default = {
   name: "@content-collections/core",
-  version: "0.1.2",
+  version: "0.3.1",
   type: "module",
-  main: "dist/index.cjs",
+  main: "dist/index.js",
   types: "./dist/index.d.ts",
   exports: {
     "./package.json": "./package.json",
@@ -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,11 @@ async function compile(configurationPath, outfile) {
   }
   await esbuild.build({
     entryPoints: [configurationPath],
-    external: [...Object.keys(package_default.dependencies), "@content-collections/*"],
+    packages: "external",
+    external: [
+      ...Object.keys(package_default.dependencies),
+      "@content-collections/*"
+    ],
     bundle: true,
     platform: "node",
     format: "esm",
@@ -144,19 +155,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 +224,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 +356,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 +386,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 +394,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 +414,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 +425,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 +455,7 @@ function createTransformer(emitter) {
           }
         }
       }
+      await cacheManager.flush();
       return docs;
     }
     return collection.documents;
@@ -438,26 +476,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 +494,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 +528,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 +547,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 +572,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 +613,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 +710,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 +724,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 +749,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,8 +1,8 @@
 {
   "name": "@content-collections/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
-  "main": "dist/index.cjs",
+  "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
@@ -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": {

package/dist/index.cjs

@@ -1,416 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  applyConfig: () => applyConfig,
-  build: () => build2,
-  createRunner: () => createRunner,
-  defineCollection: () => defineCollection,
-  defineConfig: () => defineConfig
-});
-module.exports = __toCommonJS(src_exports);
-var import_path2 = __toESM(require("path"), 1);
-
-// src/applyConfig.ts
-var esbuild = __toESM(require("esbuild"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path = __toESM(require("path"), 1);
-
-// package.json
-var package_default = {
-  name: "@mdx-collections/core",
-  version: "1.0.0",
-  type: "module",
-  main: "dist/index.cjs",
-  exports: {
-    "./package.json": "./package.json",
-    ".": {
-      import: "./dist/index.js",
-      require: "./dist/index.cjs"
-    }
-  },
-  types: "./dist/index.d.ts",
-  scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts -d dist",
-    typecheck: "tsc",
-    test: "vitest --run --coverage"
-  },
-  devDependencies: {
-    "@types/micromatch": "^4.0.6",
-    "@types/node": "^20.9.0",
-    "@types/pluralize": "^0.0.33",
-    "@vitest/coverage-v8": "^0.34.6",
-    tsup: "^7.2.0",
-    tsx: "^4.1.1",
-    typescript: "^5.3.2",
-    vitest: "^0.34.6"
-  },
-  dependencies: {
-    camelcase: "^8.0.0",
-    esbuild: "^0.19.5",
-    "fast-glob": "^3.3.2",
-    "gray-matter": "^4.0.3",
-    micromatch: "^4.0.5",
-    pluralize: "^8.0.0",
-    zod: "^3.22.4"
-  }
-};
-
-// src/applyConfig.ts
-var importPathPlugin = {
-  name: "import-path",
-  setup(build3) {
-    build3.onResolve({ filter: /^\@mdx-collections\/core$/ }, () => {
-      return { path: import_node_path.default.join(__dirname, "index.ts"), external: true };
-    });
-  }
-};
-function resolveCacheDir(config, options) {
-  if (options.cacheDir) {
-    return options.cacheDir;
-  }
-  return import_node_path.default.join(import_node_path.default.dirname(config), ".mdx-collections", "cache");
-}
-async function applyConfig(config, options = {
-  configName: "mdx-collection-config.mjs"
-}) {
-  const cacheDir = resolveCacheDir(config, options);
-  await import_promises.default.mkdir(cacheDir, { recursive: true });
-  const outfile = import_node_path.default.join(cacheDir, options.configName);
-  const plugins = [];
-  if (process.env.NODE_ENV === "test") {
-    plugins.push(importPathPlugin);
-  }
-  await esbuild.build({
-    entryPoints: [config],
-    external: [...Object.keys(package_default.dependencies), "@mdx-collections/*"],
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    plugins,
-    outfile
-  });
-  const module2 = await import(`file://${import_node_path.default.resolve(outfile)}?x=${Date.now()}`);
-  return {
-    ...module2.default,
-    path: config,
-    generateTypes: true
-  };
-}
-
-// src/run.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_pluralize = __toESM(require("pluralize"), 1);
-
-// src/collect.ts
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_promises2 = require("fs/promises");
-var import_path = __toESM(require("path"), 1);
-var import_micromatch = __toESM(require("micromatch"), 1);
-async function collectFile(directory, filePath) {
-  const file = await (0, import_promises2.readFile)(import_path.default.join(directory, filePath), "utf-8");
-  const { data, content: body } = (0, import_gray_matter.default)(file);
-  return {
-    data,
-    body,
-    path: filePath
-  };
-}
-async function resolveCollection(collection) {
-  const filePaths = await (0, import_fast_glob.default)(collection.include, {
-    cwd: collection.directory,
-    onlyFiles: true,
-    absolute: false
-  });
-  const promises = filePaths.map(
-    (filePath) => collectFile(collection.directory, filePath)
-  );
-  return {
-    ...collection,
-    files: await Promise.all(promises)
-  };
-}
-async function collect(unresolvedCollections) {
-  const promises = unresolvedCollections.map(
-    (collection) => resolveCollection(collection)
-  );
-  return await Promise.all(promises);
-}
-function createRelativePath(directory, filePath) {
-  if (!filePath.startsWith(directory)) {
-    throw new Error("Path is not in collection directory");
-  }
-  let relativePath = filePath.slice(directory.length);
-  if (relativePath.startsWith("/")) {
-    relativePath = relativePath.slice(1);
-  }
-  return relativePath;
-}
-function isIncluded(collection, path5) {
-  if (path5.startsWith(collection.directory)) {
-    const relativePath = createRelativePath(collection.directory, path5);
-    return import_micromatch.default.isMatch(relativePath, collection.include);
-  }
-  return false;
-}
-async function syncFile(collection, modification, path5) {
-  if ("added" === modification) {
-    const file = await collectFile(collection.directory, path5);
-    collection.files.push(file);
-  } else if ("changed" === modification) {
-    const file = await collectFile(collection.directory, path5);
-    const index = collection.files.findIndex((file2) => file2.path === path5);
-    collection.files[index] = file;
-  } else if ("removed" === modification) {
-    const index = collection.files.findIndex((file) => file.path === path5);
-    collection.files.splice(index, 1);
-  }
-}
-function sync(collection, modification, path5) {
-  const relativePath = createRelativePath(collection.directory, path5);
-  return syncFile(collection, modification, relativePath);
-}
-
-// src/transformer.ts
-var TransformError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-var throwingErrorHandler = (error) => {
-  throw error;
-};
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-async function transform(untransformedCollections, errorHandler = throwingErrorHandler) {
-  async function parseFile(collection, file) {
-    const { data, body, path: path5 } = file;
-    let parsedData = await collection.schema.safeParseAsync(data);
-    if (!parsedData.success) {
-      errorHandler(new TransformError("Validation", parsedData.error.message));
-      return null;
-    }
-    const document = {
-      ...parsedData.data,
-      _meta: {
-        path: path5
-      }
-    };
-    return {
-      document,
-      content: body
-    };
-  }
-  async function parseCollection(collection) {
-    const promises2 = collection.files.map(
-      (file) => parseFile(collection, file)
-    );
-    return {
-      ...collection,
-      documents: (await Promise.all(promises2)).filter(isDefined)
-    };
-  }
-  function createContext(collections2, file) {
-    return {
-      content: async () => file.content,
-      documents: (collection) => {
-        const resolved = collections2.find((c) => c.name === collection.name);
-        if (!resolved) {
-          throw new TransformError(
-            "Configuration",
-            `Collection ${collection.name} not found, do you have registered it in your configuration?`
-          );
-        }
-        return resolved.documents.map((doc) => doc.document);
-      }
-    };
-  }
-  async function transformCollection(collections2, collection) {
-    if (collection.transform) {
-      const docs = [];
-      for (const doc of collection.documents) {
-        const context = createContext(collections2, doc);
-        try {
-          docs.push({
-            ...doc,
-            document: await collection.transform(context, doc.document)
-          });
-        } catch (error) {
-          if (error instanceof TransformError) {
-            errorHandler(error);
-          } else {
-            errorHandler(new TransformError("Transform", String(error)));
-          }
-        }
-      }
-      return docs;
-    }
-    return collection.documents;
-  }
-  const promises = untransformedCollections.map(
-    (collection) => parseCollection(collection)
-  );
-  const collections = await Promise.all(promises);
-  for (const collection of collections) {
-    collection.documents = await transformCollection(collections, collection);
-  }
-  return collections;
-}
-
-// src/run.ts
-function createArrayConstName(name) {
-  let suffix = name.charAt(0).toUpperCase() + name.slice(1);
-  return "all" + (0, import_pluralize.default)(suffix);
-}
-async function createDataFiles(collections, directory) {
-  for (const collection of collections) {
-    const dataPath = import_node_path2.default.join(
-      directory,
-      `${createArrayConstName(collection.name)}.json`
-    );
-    await import_promises3.default.writeFile(
-      dataPath,
-      JSON.stringify(
-        collection.documents.map((doc) => doc.document),
-        null,
-        2
-      )
-    );
-  }
-}
-async function createJavaScriptFile(configuration, directory) {
-  const collections = configuration.collections.map(
-    ({ name }) => createArrayConstName(name)
-  );
-  let content = "";
-  for (const name of collections) {
-    content += `import ${name} from "./${name}.json";
-`;
-  }
-  content += "\n";
-  content += "export { " + collections.join(", ") + " };\n";
-  await import_promises3.default.writeFile(import_node_path2.default.join(directory, "index.js"), content, "utf-8");
-}
-async function createTypeDefinitionFile(configuration, directory) {
-  const importPath = import_node_path2.default.relative(directory, configuration.path);
-  let content = `import mdxConfiguration from "${importPath}";
-import { GetTypeByName } from "@mdx-collections/core";
-`;
-  const collections = configuration.collections;
-  for (const collection of collections) {
-    content += `
-`;
-    content += `export type ${collection.typeName} = GetTypeByName<typeof mdxConfiguration, "${collection.name}">;
-`;
-    content += `export declare const ${createArrayConstName(
-      collection.name
-    )}: Array<${collection.typeName}>;
-`;
-  }
-  content += "\n";
-  content += "export {};\n";
-  await import_promises3.default.writeFile(import_node_path2.default.join(directory, "index.d.ts"), content, "utf-8");
-}
-async function createRunner(configuration, directory) {
-  await import_promises3.default.mkdir(directory, { recursive: true });
-  const resolved = await collect(configuration.collections);
-  await createJavaScriptFile(configuration, directory);
-  if (configuration.generateTypes) {
-    await createTypeDefinitionFile(configuration, directory);
-  }
-  async function run() {
-    const collections = await transform(resolved);
-    await createDataFiles(collections, directory);
-    for (const collection of collections) {
-      if (collection.onSuccess) {
-        await collection.onSuccess(
-          collection.documents.map((doc) => doc.document)
-        );
-      }
-    }
-  }
-  return {
-    run,
-    sync: async (event, path5) => {
-      for (const collection of resolved) {
-        if (isIncluded(collection, path5)) {
-          await sync(collection, event, path5);
-          await run();
-        }
-      }
-    }
-  };
-}
-
-// src/utils.ts
-var import_camelcase = __toESM(require("camelcase"), 1);
-var import_pluralize2 = __toESM(require("pluralize"), 1);
-function generateTypeName(name) {
-  const singularName = import_pluralize2.default.singular(name);
-  return (0, import_camelcase.default)(singularName, { pascalCase: true });
-}
-
-// src/config.ts
-function defineCollection(collection) {
-  let typeName = collection.typeName;
-  if (!typeName) {
-    typeName = generateTypeName(collection.name);
-  }
-  return {
-    ...collection,
-    typeName
-  };
-}
-function defineConfig(config) {
-  return config;
-}
-
-// src/index.ts
-async function build2(config) {
-  const configuration = await applyConfig(config);
-  const baseDirectory = import_path2.default.dirname(config);
-  const directory = import_path2.default.join(baseDirectory, ".mdx-collections", "generated");
-  const runner = await createRunner(configuration, directory);
-  await runner.run();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyConfig,
-  build,
-  createRunner,
-  defineCollection,
-  defineConfig
-});

package/dist/index.d.cts

@@ -1,59 +0,0 @@
-import { ZodTypeAny, z } from 'zod';
-
-type Meta = {
-    path: string;
-};
-type Document<TSchema extends ZodTypeAny> = z.infer<TSchema> & {
-    _meta: Meta;
-};
-type Context = {
-    content(): Promise<string>;
-    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Document<TCollection["schema"]>>;
-};
-type TransformFn<TSchema extends ZodTypeAny> = ((context: Context, data: Document<TSchema>) => any) | undefined;
-type CollectionRequest<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument> = {
-    name: TName;
-    typeName?: string;
-    schema: TSchema;
-    transform?: TTransform;
-    directory: string;
-    include: string | string[];
-    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
-};
-type Collection<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument> = CollectionRequest<TSchema, TName, TTransform, TDocument> & {
-    typeName: string;
-};
-type AnyCollection = Collection<ZodTypeAny, any, any, any>;
-declare function defineCollection<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument = [TTransform] extends [(...args: any) => any] ? Awaited<ReturnType<TTransform>> : Document<TSchema>>(collection: CollectionRequest<TSchema, TName, TTransform, TDocument>): Collection<TSchema, TName, TTransform, TDocument>;
-type Configuration<TCollections extends Array<AnyCollection>> = {
-    collections: TCollections;
-};
-type AnyConfiguration = Configuration<Array<AnyCollection>>;
-declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
-
-type InternalConfiguration = {
-    collections: Array<AnyCollection>;
-    path: string;
-    generateTypes?: boolean;
-};
-type Options = {
-    configName: string;
-    cacheDir?: string;
-};
-declare function applyConfig(config: string, options?: Options): Promise<InternalConfiguration>;
-
-type Modification = "added" | "changed" | "removed";
-type CollectionByName<TConfiguration extends AnyConfiguration> = {
-    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
-};
-type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<ZodTypeAny, 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;
-
-declare function createRunner(configuration: InternalConfiguration, directory: string): Promise<{
-    run: () => Promise<void>;
-    sync: (event: Modification, path: string) => Promise<void>;
-}>;
-
-declare function build(config: string): Promise<void>;
-
-export { AnyCollection, AnyConfiguration, Collection, CollectionRequest, Configuration, Context, Document, GetTypeByName, Meta, Modification, applyConfig, build, createRunner, defineCollection, defineConfig };