@content-collections/core 0.10.0 → 0.11.1

package/dist/index.d.ts

@@ -60,7 +60,7 @@ declare const literalSchema: z__default.ZodUnion<[z__default.ZodString, z__defau
 type Literal = z__default.infer<typeof literalSchema>;
 type SchemaType = Literal | {
     [key: string]: SchemaType;
-} | SchemaType[];
+} | ReadonlyArray<SchemaType>;
 type NotSerializableError = `The return type of the transform function must be an object serializable object.
 See https://www.content-collections.dev/docs/serialization for more information.
 
@@ -95,6 +95,11 @@ type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 type GetSchema<TCollection extends AnyCollection> = TCollection extends Collection<any, any, any, infer TSchema, any, any> ? Prettify<TSchema> : never;
+declare const skippedSymbol: unique symbol;
+type SkippedSignal = {
+    [skippedSymbol]: true;
+    reason?: string;
+};
 type Context<TSchema = unknown> = {
     documents<TCollection extends AnyCollection>(collection: TCollection): Array<GetSchema<TCollection>>;
     cache: CacheFn;
@@ -103,6 +108,7 @@ type Context<TSchema = unknown> = {
         directory: string;
         documents: () => Promise<Array<TSchema>>;
     };
+    skip: (reason?: string) => SkippedSignal;
 };
 type Z = typeof z$1;
 type CollectionRequest<TName extends string, TShape extends TSchemaProp, TParser, TSchema, TTransformResult, TDocument> = {
@@ -130,7 +136,7 @@ type InvalidReturnType<TMessage extends string, TObject> = {
 type ResolveImports<TTransformResult> = TTransformResult extends Import<any> ? GetTypeOfImport<TTransformResult> : TTransformResult extends Array<infer U> ? Array<ResolveImports<U>> : TTransformResult extends (...args: any[]) => any ? TTransformResult : TTransformResult extends object ? {
     [K in keyof TTransformResult]: ResolveImports<TTransformResult[K]>;
 } : TTransformResult;
-declare function defineCollection<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser = "frontmatter", TSchema = Schema<TParser, TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TParser, TShape> : Awaited<TTransformResult>, TResult = TDocument extends Serializable ? Collection<TName, TShape, TParser, TSchema, TTransformResult, ResolveImports<TDocument>> : InvalidReturnType<NotSerializableError, TDocument>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): TResult;
+declare function defineCollection<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser = "frontmatter", TSchema = Schema<TParser, TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TParser, TShape> : Exclude<Awaited<TTransformResult>, SkippedSignal>, TResult = TDocument extends Serializable ? Collection<TName, TShape, TParser, TSchema, TTransformResult, ResolveImports<TDocument>> : InvalidReturnType<NotSerializableError, TDocument>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): TResult;
 type Cache = "memory" | "file" | "none";
 type Configuration<TCollections extends Array<AnyCollection>> = {
     collections: TCollections;
@@ -187,6 +193,11 @@ type TransformerEvents = {
         collection: AnyCollection;
         error: TransformError;
     };
+    "transformer:document-skipped": {
+        collection: AnyCollection;
+        filePath: string;
+        reason?: string;
+    };
 };
 type ErrorType$1 = "Validation" | "Configuration" | "Transform" | "Result";
 declare class TransformError extends Error {
@@ -248,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;
@@ -299,7 +317,18 @@ declare function createBuilder(configurationPath: string, options?: Options, emi
         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" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+        <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "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;
+    };
+}>;
+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;
     };
 }>;
@@ -309,6 +338,6 @@ 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, TransformError, type Watcher, createBuilder, createDefaultImport, createNamedImport, defineCollection, defineConfig, defineParser, 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,27 +102,331 @@ 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.0/node_modules/bundle-require/dist/index.js
+// ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.25.6/node_modules/bundle-require/dist/index.js
 import {
   build,
   context
 } 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
     );
@@ -292,7 +596,7 @@ var loadTsConfigInternal = (dir = process.cwd(), name = "tsconfig.json", isExten
 };
 var loadTsConfig = (dir, name) => loadTsConfigInternal(dir, name);
 
-// ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.25.0/node_modules/bundle-require/dist/index.js
+// ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.25.6/node_modules/bundle-require/dist/index.js
 var tsconfigPathsToRegExp = (paths) => {
   return Object.keys(paths || {}).map((key) => {
     return new RegExp(`^${key.replace(/\*/, ".*")}$`);
@@ -365,340 +669,96 @@ async function compile(configurationPath, outfile) {
     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;
-          }
-          return path10.startsWith(otherPath);
-        });
-      })
-    )
-  );
-}
-function posixToNativePath(pathName) {
-  if (path4.sep !== path4.posix.sep) {
-    return pathName.replaceAll(path4.posix.sep, path4.sep);
-  }
-  return pathName;
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+  });
+  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;
-    }
+var defaultConfigName = "content-collection-config.mjs";
+function resolveCacheDir(config, options) {
+  if (options.cacheDir) {
+    return options.cacheDir;
   }
-  async function collectFile(collection, filePath) {
-    const absolutePath = path5.join(
-      baseDirectory,
-      collection.directory,
-      filePath
-    );
-    const file = await read(absolutePath);
-    if (!file) {
-      return null;
+  return path6.join(path6.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 = path6.join(cacheDir, options.configName);
     try {
-      const parser = getParser(collection.parser);
-      const data = await parser.parse(file);
+      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 {
-        data,
-        path: filePath
+        ...module.default,
+        path: configurationPath,
+        inputPaths: configurationPaths.map((p) => path6.resolve(p)),
+        generateTypes: true,
+        checksum
       };
     } 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];
-      }
+      throw new ConfigurationError(
+        "Compile",
+        `configuration file ${configurationPath} is invalid: ${error}`
+      );
     }
-    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);
-  }
-  return {
-    collect,
-    collectFile
   };
 }
 
-// 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 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);
-      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
-      });
-    });
+// src/config.ts
+var skippedSymbol = Symbol("skipped");
+var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
+function defineCollection(collection) {
+  let typeName = collection.typeName;
+  if (!typeName) {
+    typeName = generateTypeName(collection.name);
   }
-  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;
+  let parser = collection.parser;
+  if (!parser) {
+    parser = "frontmatter";
+  } else if (!isValidParser(parser)) {
+    throw new ConfigurationError(
+      "Read",
+      `Parser ${parser} is not valid a parser`
+    );
   }
-  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;
+  let schema2 = collection.schema;
+  if (!schema2["~standard"]) {
+    warnDeprecated("legacySchema");
+    schema2 = z.object(schema2(z));
   }
   return {
-    deleted,
-    changed
+    ...collection,
+    typeName,
+    parser,
+    schema: schema2
   };
 }
-
-// src/transformer.ts
-import os from "node:os";
-import { basename, dirname as dirname2, extname } from "node:path";
-import pLimit from "p-limit";
+function defineConfig(config) {
+  return config;
+}
 
 // src/serializer.ts
 import serializeJs from "serialize-javascript";
-import z from "zod";
+import z2 from "zod";
 
 // src/import.ts
 var importSymbol = Symbol("import");
@@ -720,24 +780,24 @@ function createNamedImport(name, path10) {
 }
 
 // src/serializer.ts
-var literalSchema = z.union([
+var literalSchema = z2.union([
   // json
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null(),
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null(),
   // serializable-javascript
-  z.undefined(),
-  z.date(),
-  z.map(z.unknown(), z.unknown()),
-  z.set(z.unknown()),
-  z.bigint()
+  z2.undefined(),
+  z2.date(),
+  z2.map(z2.unknown(), z2.unknown()),
+  z2.set(z2.unknown()),
+  z2.bigint()
 ]);
-var schema = z.lazy(
-  () => z.union([literalSchema, z.array(schema), z.record(schema)])
+var schema = z2.lazy(
+  () => z2.union([literalSchema, z2.array(schema), z2.record(schema)])
 );
 var extension = "js";
-var serializableSchema = z.record(schema);
+var serializableSchema = z2.record(schema);
 function createImport(imp, variableName) {
   const variableDeclaration = imp.name ? `{ ${imp.name} as ${variableName} }` : variableName;
   return `import ${variableDeclaration} from "${imp.path}";
@@ -781,6 +841,9 @@ var TransformError = class extends Error {
     this.type = type;
   }
 };
+function isSkippedSignal(signal) {
+  return signal[skippedSymbol] === true;
+}
 function createPath(path10, ext) {
   let p = path10.slice(0, -ext.length);
   if (p.endsWith("/index")) {
@@ -872,7 +935,11 @@ function createTransformer(emitter, cacheManager) {
           return collection.documents.map((doc) => doc.document);
         }
       },
-      cache: cache.cacheFn
+      cache: cache.cacheFn,
+      skip: (reason) => ({
+        [skippedSymbol]: true,
+        reason
+      })
     };
   }
   async function transformDocument(collections, collection, transform, doc) {
@@ -881,10 +948,18 @@ function createTransformer(emitter, cacheManager) {
     try {
       const document = await transform(doc.document, context2);
       await cache.tidyUp();
-      return {
-        ...doc,
-        document
-      };
+      if (isSkippedSignal(document)) {
+        emitter.emit("transformer:document-skipped", {
+          collection,
+          filePath: join3(collection.directory, doc.document._meta.filePath),
+          reason: document.reason
+        });
+      } else {
+        return {
+          ...doc,
+          document
+        };
+      }
     } catch (error) {
       if (error instanceof TransformError) {
         emitter.emit("transformer:error", {
@@ -1191,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,
@@ -1283,63 +1369,6 @@ async function createBuilder(configurationPath, options = {
     on: emitter.on
   };
 }
-
-// src/config.ts
-import { z as z2 } 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 InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
-function defineCollection(collection) {
-  let typeName = collection.typeName;
-  if (!typeName) {
-    typeName = generateTypeName(collection.name);
-  }
-  let parser = collection.parser;
-  if (!parser) {
-    parser = "frontmatter";
-  }
-  let schema2 = collection.schema;
-  if (!schema2["~standard"]) {
-    warnDeprecated("legacySchema");
-    schema2 = z2.object(schema2(z2));
-  }
-  return {
-    ...collection,
-    typeName,
-    parser,
-    schema: schema2
-  };
-}
-function defineConfig(config) {
-  return config;
-}
 export {
   CollectError,
   ConfigurationError,
@@ -1347,9 +1376,11 @@ export {
   TransformError,
   createBuilder,
   createDefaultImport,
+  createInternalBuilder,
   createNamedImport,
   defineCollection,
   defineConfig,
   defineParser,
+  skippedSymbol,
   suppressDeprecatedWarnings
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@content-collections/core",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Core of Content Collections",
   "author": "Sebastian Sdorra <s.sdorra@gmail.com>",
   "license": "MIT",
@@ -33,12 +33,12 @@
     "@types/picomatch": "^3.0.1",
     "@types/pluralize": "^0.0.33",
     "@types/serialize-javascript": "^5.0.4",
-    "@vitest/coverage-v8": "^3.1.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "bundle-require": "^5.0.0",
     "tsup": "^8.2.4",
     "tsx": "^4.19.2",
     "typescript": "^5.5.4",
-    "vitest": "^3.1.3"
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
@@ -57,6 +57,6 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts -d dist",
     "typecheck": "tsc",
-    "test": "vitest --run --coverage"
+    "test": "vitest --run --coverage --typecheck"
   }
 }