@content-collections/core 0.3.0 → 0.4.0

package/README.md

@@ -110,6 +110,18 @@ Transform your content into type-safe data collections. Eliminate the need for m
 
 For a more detailed guide, please refer to the [documentation](https://content-collections.dev/docs/guides/getting-started).
 
+## Sponsors
+
+<a href="https://supastarter.dev">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./assets/sponsors/supastarter/dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="./assets/sponsors/supastarter/light.svg">
+    <img alt="supastarter" src="./assets/sponsors/supastarter/light.svg" height="64">
+  </picture>
+</a>
+
+### [Become a sponsor](https://github.com/sponsors/sdorra)
+
 ## License
 
 Content Collections is licensed under the [MIT License](./LICENSE).

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ZodRawShape, z, ZodObject, ZodTypeAny, ZodString } from 'zod';
+import z, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
 import { parse } from 'yaml';
 
 type Parsers = typeof parsers;
@@ -23,6 +23,14 @@ declare const parsers: {
 
 type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
 
+declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined]>;
+type Literal = z.infer<typeof literalSchema>;
+type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+declare const jsonObjectScheme: z.ZodRecord<z.ZodString, z.ZodType<Json, z.ZodTypeDef, Json>>;
+type JSONObject = z.infer<typeof jsonObjectScheme>;
+
 type Meta = {
     filePath: string;
     fileName: string;
@@ -38,14 +46,14 @@ type AddContent<TShape extends ZodRawShape> = TShape extends {
 } ? TShape : TShape & WithContent;
 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>>> & {
+type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z$1.infer<ZodObject<GetShape<TParser, TShape>>> & {
     _meta: Meta;
 };
 type Context = {
     documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
     cache: CacheFn;
 };
-type Z = typeof z;
+type Z = typeof z$1;
 type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser, TSchema, TTransformResult, TDocument> = {
     name: TName;
     parser?: TParser;
@@ -62,7 +70,13 @@ type Collection<TName extends string, TShape extends ZodRawShape, TParser extend
     parser: TParser;
 };
 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 NonJSONObjectError = "The return type of the transform function must be an valid JSONObject, the following type is not valid:";
+declare const InvalidReturnTypeSymbol: unique symbol;
+type InvalidReturnType<TMessage extends string, TObject> = {
+    [InvalidReturnTypeSymbol]: TMessage;
+    object: TObject;
+};
+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>, TResult = TDocument extends JSONObject ? Collection<TName, TShape, TParser, TSchema, TTransformResult, TDocument> : InvalidReturnType<NonJSONObjectError, TDocument>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): TResult;
 type Cache = "memory" | "file" | "none";
 type Configuration<TCollections extends Array<AnyCollection>> = {
     collections: TCollections;
@@ -107,12 +121,17 @@ type TransformerEvents = {
         file: CollectionFile;
         error: TransformError;
     };
+    "transformer:result-error": {
+        collection: AnyCollection;
+        document: any;
+        error: TransformError;
+    };
     "transformer:error": {
         collection: AnyCollection;
         error: TransformError;
     };
 };
-type ErrorType$1 = "Validation" | "Configuration" | "Transform";
+type ErrorType$1 = "Validation" | "Configuration" | "Transform" | "Result";
 declare class TransformError extends Error {
     type: ErrorType$1;
     constructor(type: ErrorType$1, message: string);
@@ -167,7 +186,7 @@ declare function createBuilder(configurationPath: string, options?: Options): Pr
         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 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;
     };
 }>;

package/dist/index.js

@@ -16,6 +16,7 @@ function orderByPath(a, b) {
 }
 
 // src/config.ts
+var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
 function defineCollection(collection) {
   let typeName = collection.typeName;
   if (!typeName) {
@@ -44,9 +45,9 @@ import path from "path";
 // package.json
 var package_default = {
   name: "@content-collections/core",
-  version: "0.3.0",
+  version: "0.4.0",
   type: "module",
-  main: "dist/index.cjs",
+  main: "dist/index.js",
   types: "./dist/index.d.ts",
   exports: {
     "./package.json": "./package.json",
@@ -121,6 +122,7 @@ async function compile(configurationPath, outfile) {
   }
   await esbuild.build({
     entryPoints: [configurationPath],
+    packages: "external",
     external: [
       ...Object.keys(package_default.dependencies),
       "@content-collections/*"
@@ -347,7 +349,23 @@ async function createWriter(directory) {
 
 // src/transformer.ts
 import { basename, dirname, extname } from "path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+
+// src/json.ts
+import z2 from "zod";
+var literalSchema = z2.union([
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null(),
+  z2.undefined()
+]);
+var jsonSchema = z2.lazy(
+  () => z2.union([literalSchema, z2.array(jsonSchema), z2.record(jsonSchema)])
+);
+var jsonObjectScheme = z2.record(jsonSchema);
+
+// src/transformer.ts
 var TransformError = class extends Error {
   type;
   constructor(type, message) {
@@ -366,10 +384,10 @@ function createTransformer(emitter, cacheManager) {
   function createSchema(parserName, schema) {
     const parser = parsers[parserName];
     if (!parser.hasContent) {
-      return z2.object(schema);
+      return z3.object(schema);
     }
-    return z2.object({
-      content: z2.string(),
+    return z3.object({
+      content: z3.string(),
       ...schema
     });
   }
@@ -432,12 +450,16 @@ function createTransformer(emitter, cacheManager) {
     if (collection.transform) {
       const docs = [];
       for (const doc of collection.documents) {
-        const cache = cacheManager.cache(collection.name, doc.document._meta.path);
+        const cache = cacheManager.cache(
+          collection.name,
+          doc.document._meta.path
+        );
         const context = createContext(collections, cache);
         try {
+          const document = await collection.transform(doc.document, context);
           docs.push({
             ...doc,
-            document: await collection.transform(doc.document, context)
+            document
           });
           await cache.tidyUp();
         } catch (error) {
@@ -459,13 +481,30 @@ function createTransformer(emitter, cacheManager) {
     }
     return collection.documents;
   }
+  async function validateDocuments(collection, documents) {
+    const docs = [];
+    for (const doc of documents) {
+      let parsedData = await jsonObjectScheme.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) {
-      collection.documents = await transformCollection(collections, collection);
+      const documents = await transformCollection(collections, collection);
+      collection.documents = await validateDocuments(collection, documents);
     }
     return collections;
   };
@@ -475,9 +514,9 @@ function createTransformer(emitter, cacheManager) {
 import micromatch from "micromatch";
 import path4 from "path";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollection(filePath) {
+  function findCollections(filePath) {
     const resolvedFilePath = path4.resolve(filePath);
-    return collections.find((collection) => {
+    return collections.filter((collection) => {
       return resolvedFilePath.startsWith(
         path4.resolve(baseDirectory, collection.directory)
       );
@@ -493,51 +532,56 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
     return relativePath;
   }
   function resolve(filePath) {
-    const collection = findCollection(filePath);
-    if (!collection) {
-      return null;
-    }
-    const relativePath = createRelativePath(collection.directory, filePath);
-    if (!micromatch.isMatch(relativePath, collection.include)) {
-      return null;
-    }
-    return {
-      collection,
-      relativePath
-    };
+    const collections2 = findCollections(filePath);
+    return collections2.map((collection) => {
+      const relativePath = createRelativePath(collection.directory, filePath);
+      return {
+        collection,
+        relativePath
+      };
+    }).filter(({ collection, relativePath }) => {
+      return micromatch.isMatch(relativePath, collection.include);
+    });
   }
   function deleted(filePath) {
-    const resolved = resolve(filePath);
-    if (!resolved) {
+    const resolvedCollections = resolve(filePath);
+    if (resolvedCollections.length === 0) {
       return false;
     }
-    const { collection, relativePath } = resolved;
-    const index = collection.files.findIndex(
-      (file) => file.path === relativePath
-    );
-    const deleted2 = collection.files.splice(index, 1);
-    return deleted2.length > 0;
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file) => file.path === relativePath
+      );
+      const deleted2 = collection.files.splice(index, 1);
+      if (deleted2.length > 0) {
+        changed2 = true;
+      }
+    }
+    return changed2;
   }
   async function changed(filePath) {
-    const resolved = resolve(filePath);
-    if (!resolved) {
+    const resolvedCollections = resolve(filePath);
+    if (resolvedCollections.length === 0) {
       return false;
     }
-    const { collection, relativePath } = resolved;
-    const index = collection.files.findIndex(
-      (file2) => file2.path === relativePath
-    );
-    const file = await readCollectionFile(collection, relativePath);
-    if (!file) {
-      return false;
-    }
-    if (index === -1) {
-      collection.files.push(file);
-      collection.files.sort(orderByPath);
-    } else {
-      collection.files[index] = file;
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file2) => file2.path === relativePath
+      );
+      const file = await readCollectionFile(collection, relativePath);
+      if (file) {
+        changed2 = true;
+        if (index === -1) {
+          collection.files.push(file);
+          collection.files.sort(orderByPath);
+        } else {
+          collection.files[index] = file;
+        }
+      }
     }
-    return true;
+    return changed2;
   }
   return {
     deleted,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@content-collections/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
-  "main": "dist/index.cjs",
+  "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",

package/dist/apidoc.d.ts

@@ -1,186 +0,0 @@
-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.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 };