@content-collections/core 0.11.0 → 0.11.1

package/dist/index.d.ts

@@ -259,6 +259,13 @@ declare class ConfigurationError extends Error {
     type: ErrorType;
     constructor(type: ErrorType, message: string);
 }
+type InternalConfiguration = {
+    collections: Array<AnyCollection>;
+    path: string;
+    inputPaths: Array<string>;
+    checksum: string;
+    generateTypes?: boolean;
+};
 type Options$1 = {
     configName: string;
     cacheDir?: string;
@@ -314,12 +321,23 @@ declare function createBuilder(configurationPath: string, options?: Options, emi
         <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
     };
 }>;
+declare function createInternalBuilder(initialConfiguration: InternalConfiguration, baseDirectory: string, options: Options, emitter: Emitter): Promise<{
+    build: () => Promise<void>;
+    sync: (modification: Modification, filePath: string) => Promise<boolean>;
+    watch: () => Promise<{
+        unsubscribe: () => Promise<void>;
+    }>;
+    on: {
+        <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "transformer:document-skipped" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+        <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
+    };
+}>;
 type Builder = Awaited<ReturnType<typeof createBuilder>>;
 
 declare const deprecations: {
     legacySchema: string;
 };
 type Deprecation = keyof typeof deprecations;
-declare function suppressDeprecatedWarnings(...deprecations: Array<Deprecation | "all">): void;
+declare function suppressDeprecatedWarnings(...suppresses: Array<Deprecation | "all">): void;
 
-export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, ConfigurationReloadError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, type SkippedSignal, TransformError, type Watcher, createBuilder, createDefaultImport, createNamedImport, defineCollection, defineConfig, defineParser, skippedSymbol, suppressDeprecatedWarnings };
+export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, ConfigurationReloadError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, type SkippedSignal, TransformError, type Watcher, createBuilder, createDefaultImport, createInternalBuilder, createNamedImport, defineCollection, defineConfig, defineParser, skippedSymbol, suppressDeprecatedWarnings };

package/dist/index.js

@@ -102,18 +102,322 @@ async function createCacheManager(baseDirectory, configChecksum) {
 
 // src/collector.ts
 import { readFile as readFile2 } from "fs/promises";
-import path5 from "node:path";
+import path3 from "node:path";
 import { glob } from "tinyglobby";
 
 // src/parser.ts
 import matter from "gray-matter";
 import { parse, stringify } from "yaml";
+function parseYaml(content) {
+  return parse(content.trim());
+}
+function frontmatter(fileContent) {
+  return matter(fileContent, {
+    engines: {
+      yaml: {
+        parse: parseYaml,
+        stringify
+      }
+    }
+  });
+}
+function frontmatterParser(fileContent) {
+  const { data, content } = frontmatter(fileContent);
+  return {
+    ...data,
+    content: content.trim()
+  };
+}
+function frontmatterOnlyParser(fileContent) {
+  const { data } = frontmatter(fileContent);
+  return data;
+}
+var parsers = {
+  frontmatter: {
+    hasContent: true,
+    parse: frontmatterParser
+  },
+  ["frontmatter-only"]: {
+    hasContent: false,
+    parse: frontmatterOnlyParser
+  },
+  json: {
+    hasContent: false,
+    parse: JSON.parse
+  },
+  yaml: {
+    hasContent: false,
+    parse: parseYaml
+  }
+};
+function getParser(configuredParser) {
+  if (typeof configuredParser === "string") {
+    return parsers[configuredParser];
+  }
+  return configuredParser;
+}
+function defineParser(parser) {
+  if (typeof parser === "function") {
+    return {
+      hasContent: false,
+      parse: parser
+    };
+  }
+  return parser;
+}
+function isValidParser(parser) {
+  if (typeof parser === "string") {
+    return parser in parsers;
+  }
+  return "hasContent" in parser && typeof parser.parse === "function";
+}
+
+// src/utils.ts
+import camelcase from "camelcase";
+import pluralize from "pluralize";
+import path2 from "node:path";
+function generateTypeName(name) {
+  const singularName = pluralize.singular(name);
+  return camelcase(singularName, { pascalCase: true });
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function orderByPath(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function removeChildPaths(paths) {
+  return Array.from(
+    new Set(
+      paths.filter((path10) => {
+        return !paths.some((otherPath) => {
+          if (path10 === otherPath) {
+            return false;
+          }
+          return path10.startsWith(otherPath);
+        });
+      })
+    )
+  );
+}
+function posixToNativePath(pathName) {
+  if (path2.sep !== path2.posix.sep) {
+    return pathName.replaceAll(path2.posix.sep, path2.sep);
+  }
+  return pathName;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/collector.ts
+var CollectError = class extends Error {
+  type;
+  constructor(type, message) {
+    super(message);
+    this.type = type;
+  }
+};
+function createCollector(emitter, baseDirectory = ".") {
+  async function read(filePath) {
+    try {
+      return await readFile2(filePath, "utf-8");
+    } catch (error) {
+      emitter.emit("collector:read-error", {
+        filePath,
+        error: new CollectError("Read", String(error))
+      });
+      return null;
+    }
+  }
+  async function collectFile(collection, filePath) {
+    const absolutePath = path3.join(
+      baseDirectory,
+      collection.directory,
+      filePath
+    );
+    const file = await read(absolutePath);
+    if (!file) {
+      return null;
+    }
+    try {
+      const parser = getParser(collection.parser);
+      const data = await parser.parse(file);
+      return {
+        data,
+        path: filePath
+      };
+    } catch (error) {
+      emitter.emit("collector:parse-error", {
+        filePath: path3.join(collection.directory, filePath),
+        error: new CollectError("Parse", String(error))
+      });
+      return null;
+    }
+  }
+  function createIgnorePattern(collection) {
+    if (collection.exclude) {
+      if (Array.isArray(collection.exclude)) {
+        return collection.exclude;
+      } else {
+        return [collection.exclude];
+      }
+    }
+    return void 0;
+  }
+  async function resolveCollection(collection) {
+    const collectionDirectory = path3.join(baseDirectory, collection.directory);
+    const include = Array.isArray(collection.include) ? collection.include : [collection.include];
+    const filePaths = await glob(include, {
+      cwd: collectionDirectory,
+      onlyFiles: true,
+      absolute: false,
+      ignore: createIgnorePattern(collection)
+    });
+    const promises = filePaths.map(
+      (filePath) => collectFile(collection, posixToNativePath(filePath))
+    );
+    const files = await Promise.all(promises);
+    return {
+      ...collection,
+      files: files.filter(isDefined).sort(orderByPath)
+    };
+  }
+  async function collect(unresolvedCollections) {
+    const promises = unresolvedCollections.map(
+      (collection) => resolveCollection(collection)
+    );
+    return await Promise.all(promises);
+  }
+  return {
+    collect,
+    collectFile
+  };
+}
+
+// src/synchronizer.ts
+import path4 from "node:path";
+import picomatch from "picomatch";
+function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
+  function findCollections(filePath) {
+    const resolvedFilePath = path4.resolve(filePath);
+    return collections.filter((collection) => {
+      return resolvedFilePath.startsWith(
+        path4.resolve(baseDirectory, collection.directory)
+      );
+    });
+  }
+  function createRelativePath(collectionPath, filePath) {
+    const resolvedCollectionPath = path4.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path4.resolve(filePath);
+    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
+    if (relativePath.startsWith(path4.sep)) {
+      relativePath = relativePath.slice(path4.sep.length);
+    }
+    return relativePath;
+  }
+  function resolve2(filePath) {
+    const collections2 = findCollections(filePath);
+    return collections2.map((collection) => {
+      const relativePath = createRelativePath(collection.directory, filePath);
+      return {
+        collection,
+        relativePath
+      };
+    }).filter(({ collection, relativePath }) => {
+      return picomatch.isMatch(relativePath, collection.include, {
+        // @see https://github.com/sdorra/content-collections/issues/602
+        windows: process.platform === "win32",
+        ignore: collection.exclude
+      });
+    });
+  }
+  function deleted(filePath) {
+    const resolvedCollections = resolve2(filePath);
+    if (resolvedCollections.length === 0) {
+      return false;
+    }
+    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 resolvedCollections = resolve2(filePath);
+    if (resolvedCollections.length === 0) {
+      return false;
+    }
+    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 changed2;
+  }
+  return {
+    deleted,
+    changed
+  };
+}
+
+// src/transformer.ts
+import os from "node:os";
+import { basename, dirname as dirname2, extname, join as join3 } from "node:path";
+import pLimit from "p-limit";
+
+// src/config.ts
+import { z } from "zod";
+
+// src/warn.ts
+var deprecations = {
+  legacySchema: `The use of a function as a schema is deprecated.
+Please use a StandardSchema compliant library directly.
+For more information, see:
+https://content-collections.dev/docs/deprecations/schema-as-function`
+};
+var _suppressDeprecatedWarnings = [];
+function suppressDeprecatedWarnings(...suppresses) {
+  for (const deprecation of suppresses) {
+    if (deprecation === "all") {
+      _suppressDeprecatedWarnings.push(
+        ...Object.keys(deprecations)
+      );
+      return;
+    } else {
+      _suppressDeprecatedWarnings.push(deprecation);
+    }
+  }
+}
+function warnDeprecated(deprecation, logger = console.warn) {
+  if (_suppressDeprecatedWarnings.includes(deprecation)) {
+    return;
+  }
+  logger(`[CC DEPRECATED]: ${deprecations[deprecation]}`);
+}
 
 // src/configurationReader.ts
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import fs2 from "node:fs/promises";
-import path3 from "node:path";
+import path6 from "node:path";
 
 // ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.25.6/node_modules/bundle-require/dist/index.js
 import {
@@ -122,7 +426,7 @@ import {
 } from "esbuild";
 
 // ../../node_modules/.pnpm/load-tsconfig@0.2.5/node_modules/load-tsconfig/dist/index.js
-import path2 from "path";
+import path5 from "path";
 import fs from "fs";
 import { createRequire } from "module";
 var singleComment = Symbol("singleComment");
@@ -219,10 +523,10 @@ function jsoncParse(data) {
   }
 }
 var req = true ? createRequire(import.meta.url) : __require;
-var findUp = (name, startDir, stopDir = path2.parse(startDir).root) => {
+var findUp = (name, startDir, stopDir = path5.parse(startDir).root) => {
   let dir = startDir;
   while (dir !== stopDir) {
-    const file = path2.join(dir, name);
+    const file = path5.join(dir, name);
     if (fs.existsSync(file))
       return file;
     if (!file.endsWith(".json")) {
@@ -230,17 +534,17 @@ var findUp = (name, startDir, stopDir = path2.parse(startDir).root) => {
       if (fs.existsSync(fileWithExt))
         return fileWithExt;
     }
-    dir = path2.dirname(dir);
+    dir = path5.dirname(dir);
   }
   return null;
 };
 var resolveTsConfigFromFile = (cwd, filename) => {
-  if (path2.isAbsolute(filename))
+  if (path5.isAbsolute(filename))
     return fs.existsSync(filename) ? filename : null;
   return findUp(filename, cwd);
 };
 var resolveTsConfigFromExtends = (cwd, name) => {
-  if (path2.isAbsolute(name))
+  if (path5.isAbsolute(name))
     return fs.existsSync(name) ? name : null;
   if (name.startsWith("."))
     return findUp(name, cwd);
@@ -249,14 +553,14 @@ var resolveTsConfigFromExtends = (cwd, name) => {
 };
 var loadTsConfigInternal = (dir = process.cwd(), name = "tsconfig.json", isExtends = false) => {
   var _a, _b;
-  dir = path2.resolve(dir);
+  dir = path5.resolve(dir);
   const id = isExtends ? resolveTsConfigFromExtends(dir, name) : resolveTsConfigFromFile(dir, name);
   if (!id)
     return null;
   const data = jsoncParse(fs.readFileSync(id, "utf-8"));
-  const configDir = path2.dirname(id);
+  const configDir = path5.dirname(id);
   if ((_a = data.compilerOptions) == null ? void 0 : _a.baseUrl) {
-    data.compilerOptions.baseUrl = path2.join(
+    data.compilerOptions.baseUrl = path5.join(
       configDir,
       data.compilerOptions.baseUrl
     );
@@ -326,406 +630,99 @@ function createExternalsPlugin(configPath) {
   return {
     name: "external-packages",
     setup: (build4) => {
-      build4.onResolve({ filter: /.*/ }, ({ path: path10, kind }) => {
-        if (match(path10, resolvePatterns)) {
-          if (kind === "dynamic-import") {
-            return { path: path10, external: true };
-          }
-          return;
-        }
-        if (!NON_NODE_MODULE_RE.test(path10)) {
-          return {
-            path: path10,
-            external: true
-          };
-        }
-      });
-    }
-  };
-}
-var importPathPlugin = {
-  name: "import-path",
-  setup(build4) {
-    build4.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
-      return { path: join2(__dirname, "index.ts"), external: true };
-    });
-  }
-};
-async function compile(configurationPath, outfile) {
-  const plugins = [createExternalsPlugin(configurationPath)];
-  if (process.env.NODE_ENV === "test") {
-    plugins.push(importPathPlugin);
-  }
-  const result = await build2({
-    entryPoints: [configurationPath],
-    packages: "external",
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    plugins,
-    outfile,
-    metafile: true
-  });
-  return Object.keys(result.metafile.inputs);
-}
-
-// src/configurationReader.ts
-var ConfigurationError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-var defaultConfigName = "content-collection-config.mjs";
-function resolveCacheDir(config, options) {
-  if (options.cacheDir) {
-    return options.cacheDir;
-  }
-  return path3.join(path3.dirname(config), ".content-collections", "cache");
-}
-function createConfigurationReader() {
-  return async (configurationPath, options = {
-    configName: defaultConfigName
-  }) => {
-    if (!existsSync2(configurationPath)) {
-      throw new ConfigurationError(
-        "Read",
-        `configuration file ${configurationPath} does not exist`
-      );
-    }
-    const cacheDir = resolveCacheDir(configurationPath, options);
-    await fs2.mkdir(cacheDir, { recursive: true });
-    const outfile = path3.join(cacheDir, options.configName);
-    try {
-      const configurationPaths = await compile(configurationPath, outfile);
-      const module = await import(`file://${path3.resolve(outfile)}?x=${Date.now()}`);
-      const hash = createHash2("sha256");
-      hash.update(await fs2.readFile(outfile, "utf-8"));
-      const checksum = hash.digest("hex");
-      return {
-        ...module.default,
-        path: configurationPath,
-        inputPaths: configurationPaths.map((p) => path3.resolve(p)),
-        generateTypes: true,
-        checksum
-      };
-    } catch (error) {
-      throw new ConfigurationError(
-        "Compile",
-        `configuration file ${configurationPath} is invalid: ${error}`
-      );
-    }
-  };
-}
-
-// src/parser.ts
-function parseYaml(content) {
-  return parse(content.trim());
-}
-function frontmatter(fileContent) {
-  return matter(fileContent, {
-    engines: {
-      yaml: {
-        parse: parseYaml,
-        stringify
-      }
-    }
-  });
-}
-function frontmatterParser(fileContent) {
-  const { data, content } = frontmatter(fileContent);
-  return {
-    ...data,
-    content: content.trim()
-  };
-}
-function frontmatterOnlyParser(fileContent) {
-  const { data } = frontmatter(fileContent);
-  return data;
-}
-var parsers = {
-  frontmatter: {
-    hasContent: true,
-    parse: frontmatterParser
-  },
-  ["frontmatter-only"]: {
-    hasContent: false,
-    parse: frontmatterOnlyParser
-  },
-  json: {
-    hasContent: false,
-    parse: JSON.parse
-  },
-  yaml: {
-    hasContent: false,
-    parse: parseYaml
-  }
-};
-function getParser(configuredParser) {
-  if (typeof configuredParser === "string") {
-    const parser = parsers[configuredParser];
-    if (!parser) {
-      throw new ConfigurationError(
-        "Read",
-        `Parser ${configuredParser} does not exist`
-      );
-    }
-    return parser;
-  }
-  return configuredParser;
-}
-function defineParser(parser) {
-  if (typeof parser === "function") {
-    return {
-      hasContent: false,
-      parse: parser
-    };
-  }
-  return parser;
-}
-
-// src/utils.ts
-import camelcase from "camelcase";
-import pluralize from "pluralize";
-import path4 from "node:path";
-function generateTypeName(name) {
-  const singularName = pluralize.singular(name);
-  return camelcase(singularName, { pascalCase: true });
-}
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-function orderByPath(a, b) {
-  return a.path.localeCompare(b.path);
-}
-function removeChildPaths(paths) {
-  return Array.from(
-    new Set(
-      paths.filter((path10) => {
-        return !paths.some((otherPath) => {
-          if (path10 === otherPath) {
-            return false;
+      build4.onResolve({ filter: /.*/ }, ({ path: path10, kind }) => {
+        if (match(path10, resolvePatterns)) {
+          if (kind === "dynamic-import") {
+            return { path: path10, external: true };
           }
-          return path10.startsWith(otherPath);
-        });
-      })
-    )
-  );
+          return;
+        }
+        if (!NON_NODE_MODULE_RE.test(path10)) {
+          return {
+            path: path10,
+            external: true
+          };
+        }
+      });
+    }
+  };
 }
-function posixToNativePath(pathName) {
-  if (path4.sep !== path4.posix.sep) {
-    return pathName.replaceAll(path4.posix.sep, path4.sep);
+var importPathPlugin = {
+  name: "import-path",
+  setup(build4) {
+    build4.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
+      return { path: join2(__dirname, "index.ts"), external: true };
+    });
   }
-  return pathName;
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+};
+async function compile(configurationPath, outfile) {
+  const plugins = [createExternalsPlugin(configurationPath)];
+  if (process.env.NODE_ENV === "test") {
+    plugins.push(importPathPlugin);
+  }
+  const result = await build2({
+    entryPoints: [configurationPath],
+    packages: "external",
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    plugins,
+    outfile,
+    metafile: true
+  });
+  return Object.keys(result.metafile.inputs);
 }
 
-// src/collector.ts
-var CollectError = class extends Error {
+// src/configurationReader.ts
+var ConfigurationError = class extends Error {
   type;
   constructor(type, message) {
     super(message);
     this.type = type;
   }
 };
-function createCollector(emitter, baseDirectory = ".") {
-  async function read(filePath) {
-    try {
-      return await readFile2(filePath, "utf-8");
-    } catch (error) {
-      emitter.emit("collector:read-error", {
-        filePath,
-        error: new CollectError("Read", String(error))
-      });
-      return null;
-    }
-  }
-  async function collectFile(collection, filePath) {
-    const absolutePath = path5.join(
-      baseDirectory,
-      collection.directory,
-      filePath
-    );
-    const file = await read(absolutePath);
-    if (!file) {
-      return null;
-    }
-    try {
-      const parser = getParser(collection.parser);
-      const data = await parser.parse(file);
-      return {
-        data,
-        path: filePath
-      };
-    } catch (error) {
-      emitter.emit("collector:parse-error", {
-        filePath: path5.join(collection.directory, filePath),
-        error: new CollectError("Parse", String(error))
-      });
-      return null;
-    }
-  }
-  function createIgnorePattern(collection) {
-    if (collection.exclude) {
-      if (Array.isArray(collection.exclude)) {
-        return collection.exclude;
-      } else {
-        return [collection.exclude];
-      }
-    }
-    return void 0;
-  }
-  async function resolveCollection(collection) {
-    const collectionDirectory = path5.join(baseDirectory, collection.directory);
-    const include = Array.isArray(collection.include) ? collection.include : [collection.include];
-    const filePaths = await glob(include, {
-      cwd: collectionDirectory,
-      onlyFiles: true,
-      absolute: false,
-      ignore: createIgnorePattern(collection)
-    });
-    const promises = filePaths.map(
-      (filePath) => collectFile(collection, posixToNativePath(filePath))
-    );
-    const files = await Promise.all(promises);
-    return {
-      ...collection,
-      files: files.filter(isDefined).sort(orderByPath)
-    };
-  }
-  async function collect(unresolvedCollections) {
-    const promises = unresolvedCollections.map(
-      (collection) => resolveCollection(collection)
-    );
-    return await Promise.all(promises);
+var defaultConfigName = "content-collection-config.mjs";
+function resolveCacheDir(config, options) {
+  if (options.cacheDir) {
+    return options.cacheDir;
   }
-  return {
-    collect,
-    collectFile
-  };
+  return path6.join(path6.dirname(config), ".content-collections", "cache");
 }
-
-// src/synchronizer.ts
-import path6 from "node:path";
-import picomatch from "picomatch";
-function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollections(filePath) {
-    const resolvedFilePath = path6.resolve(filePath);
-    return collections.filter((collection) => {
-      return resolvedFilePath.startsWith(
-        path6.resolve(baseDirectory, collection.directory)
+function createConfigurationReader() {
+  return async (configurationPath, options = {
+    configName: defaultConfigName
+  }) => {
+    if (!existsSync2(configurationPath)) {
+      throw new ConfigurationError(
+        "Read",
+        `configuration file ${configurationPath} does not exist`
       );
-    });
-  }
-  function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = path6.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = path6.resolve(filePath);
-    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith(path6.sep)) {
-      relativePath = relativePath.slice(path6.sep.length);
     }
-    return relativePath;
-  }
-  function resolve2(filePath) {
-    const collections2 = findCollections(filePath);
-    return collections2.map((collection) => {
-      const relativePath = createRelativePath(collection.directory, filePath);
+    const cacheDir = resolveCacheDir(configurationPath, options);
+    await fs2.mkdir(cacheDir, { recursive: true });
+    const outfile = path6.join(cacheDir, options.configName);
+    try {
+      const configurationPaths = await compile(configurationPath, outfile);
+      const module = await import(`file://${path6.resolve(outfile)}?x=${Date.now()}`);
+      const hash = createHash2("sha256");
+      hash.update(await fs2.readFile(outfile, "utf-8"));
+      const checksum = hash.digest("hex");
       return {
-        collection,
-        relativePath
+        ...module.default,
+        path: configurationPath,
+        inputPaths: configurationPaths.map((p) => path6.resolve(p)),
+        generateTypes: true,
+        checksum
       };
-    }).filter(({ collection, relativePath }) => {
-      return picomatch.isMatch(relativePath, collection.include, {
-        // @see https://github.com/sdorra/content-collections/issues/602
-        windows: process.platform === "win32",
-        ignore: collection.exclude
-      });
-    });
-  }
-  function deleted(filePath) {
-    const resolvedCollections = resolve2(filePath);
-    if (resolvedCollections.length === 0) {
-      return false;
-    }
-    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 resolvedCollections = resolve2(filePath);
-    if (resolvedCollections.length === 0) {
-      return false;
-    }
-    let changed2 = false;
-    for (const { collection, relativePath } of resolvedCollections) {
-      const index = collection.files.findIndex(
-        (file2) => file2.path === relativePath
+    } catch (error) {
+      throw new ConfigurationError(
+        "Compile",
+        `configuration file ${configurationPath} is invalid: ${error}`
       );
-      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 changed2;
-  }
-  return {
-    deleted,
-    changed
   };
 }
 
-// src/transformer.ts
-import os from "node:os";
-import { basename, dirname as dirname2, extname, join as join3 } from "node:path";
-import pLimit from "p-limit";
-
-// src/config.ts
-import { z } from "zod";
-
-// src/warn.ts
-var deprecations = {
-  legacySchema: `The use of a function as a schema is deprecated.
-Please use a StandardSchema compliant library directly.
-For more information, see:
-https://content-collections.dev/docs/deprecations/schema-as-function`
-};
-var _suppressDeprecatedWarnings = [];
-function suppressDeprecatedWarnings(...deprecations2) {
-  for (const deprecation of deprecations2) {
-    if (deprecation === "all") {
-      _suppressDeprecatedWarnings.push(
-        ...Object.keys(deprecations2)
-      );
-      return;
-    } else {
-      _suppressDeprecatedWarnings.push(deprecation);
-    }
-  }
-}
-function warnDeprecated(deprecation, logger = console.warn) {
-  if (_suppressDeprecatedWarnings.includes(deprecation)) {
-    return;
-  }
-  logger(`[CC DEPRECATED]: ${deprecations[deprecation]}`);
-}
-
 // src/config.ts
 var skippedSymbol = Symbol("skipped");
 var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
@@ -737,6 +734,11 @@ function defineCollection(collection) {
   let parser = collection.parser;
   if (!parser) {
     parser = "frontmatter";
+  } else if (!isValidParser(parser)) {
+    throw new ConfigurationError(
+      "Read",
+      `Parser ${parser} is not valid a parser`
+    );
   }
   let schema2 = collection.schema;
   if (!schema2["~standard"]) {
@@ -1264,13 +1266,24 @@ async function createBuilder(configurationPath, options = {
 }, emitter = createEmitter()) {
   const readConfiguration = createConfigurationReader();
   const baseDirectory = path9.dirname(configurationPath);
+  const configuration = await readConfiguration(configurationPath, options);
+  return createInternalBuilder(
+    configuration,
+    baseDirectory,
+    options,
+    emitter
+  );
+}
+async function createInternalBuilder(initialConfiguration, baseDirectory, options, emitter) {
+  const readConfiguration = createConfigurationReader();
+  const configurationPath = initialConfiguration.path;
   const outputDirectory = resolveOutputDir(baseDirectory, options);
   emitter.emit("builder:created", {
     createdAt: Date.now(),
     configurationPath,
     outputDirectory
   });
-  let configuration = await readConfiguration(configurationPath, options);
+  let configuration = initialConfiguration;
   let watcher = null;
   let context2 = await createBuildContext({
     emitter,
@@ -1363,6 +1376,7 @@ export {
   TransformError,
   createBuilder,
   createDefaultImport,
+  createInternalBuilder,
   createNamedImport,
   defineCollection,
   defineConfig,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@content-collections/core",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Core of Content Collections",
   "author": "Sebastian Sdorra <s.sdorra@gmail.com>",
   "license": "MIT",