@content-collections/core 0.6.1 → 0.6.3

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import z, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
-import { parse } from 'yaml';
+import z__default, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
+export * from 'zod';
 
 type Parsers = typeof parsers;
 type Parser = keyof typeof parsers;
+declare function parseYaml(content: string): any;
 declare function frontmatterParser(fileContent: string): {
     content: string;
 };
@@ -17,14 +18,14 @@ declare const parsers: {
     };
     readonly yaml: {
         readonly hasContent: false;
-        readonly parse: typeof parse;
+        readonly parse: typeof parseYaml;
     };
 };
 
 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, z.ZodDate, z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>, z.ZodBigInt]>;
-type Literal = z.infer<typeof literalSchema>;
+declare const literalSchema: z__default.ZodUnion<[z__default.ZodString, z__default.ZodNumber, z__default.ZodBoolean, z__default.ZodNull, z__default.ZodUndefined, z__default.ZodDate, z__default.ZodMap<z__default.ZodUnknown, z__default.ZodUnknown>, z__default.ZodSet<z__default.ZodUnknown>, z__default.ZodBigInt]>;
+type Literal = z__default.infer<typeof literalSchema>;
 type SchemaType = Literal | {
     [key: string]: SchemaType;
 } | SchemaType[];
@@ -32,8 +33,8 @@ type NotSerializableError = `The return type of the transform function must be a
 See https://www.content-collections.dev/docs/serialization for more information.
 
 The following type is not valid:`;
-declare const serializableSchema: z.ZodRecord<z.ZodString, z.ZodType<SchemaType, z.ZodTypeDef, SchemaType>>;
-type Serializable = z.infer<typeof serializableSchema>;
+declare const serializableSchema: z__default.ZodRecord<z__default.ZodString, z__default.ZodType<SchemaType, z__default.ZodTypeDef, SchemaType>>;
+type Serializable = z__default.infer<typeof serializableSchema>;
 
 type Meta = {
     filePath: string;

package/dist/index.js

@@ -134,11 +134,14 @@ import path2 from "path";
 // src/parser.ts
 import matter from "gray-matter";
 import { parse, stringify } from "yaml";
+function parseYaml(content) {
+  return parse(content.trim());
+}
 function frontmatterParser(fileContent) {
   const { data, content } = matter(fileContent, {
     engines: {
       yaml: {
-        parse,
+        parse: parseYaml,
         stringify
       }
     }
@@ -159,7 +162,7 @@ var parsers = {
   },
   yaml: {
     hasContent: false,
-    parse
+    parse: parseYaml
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-collections/core",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/index.cjs

@@ -1,919 +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, {
-  CollectError: () => CollectError,
-  ConfigurationError: () => ConfigurationError,
-  TransformError: () => TransformError,
-  createBuilder: () => createBuilder,
-  defineCollection: () => defineCollection,
-  defineConfig: () => defineConfig
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/config.ts
-var import_zod = require("zod");
-
-// src/utils.ts
-var import_pluralize = __toESM(require("pluralize"), 1);
-function camelCase(name) {
-  return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function generateTypeName(name) {
-  const singularName = import_pluralize.default.singular(name);
-  return camelCase(singularName);
-}
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-function orderByPath(a, b) {
-  return a.path.localeCompare(b.path);
-}
-
-// 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";
-  }
-  return {
-    ...collection,
-    typeName,
-    parser,
-    schema: collection.schema(import_zod.z)
-  };
-}
-function defineConfig(config) {
-  return config;
-}
-
-// src/configurationReader.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: "@content-collections/core",
-  version: "0.6.0",
-  type: "module",
-  main: "dist/index.cjs",
-  types: "./dist/index.d.cts",
-  exports: {
-    "./package.json": "./package.json",
-    ".": {
-      import: {
-        default: "./dist/index.js",
-        types: "./dist/index.d.ts"
-      },
-      require: {
-        default: "./dist/index.cjs",
-        types: "./dist/index.d.cts"
-      }
-    }
-  },
-  files: [
-    "dist",
-    "README.md"
-  ],
-  scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts -d dist",
-    typecheck: "tsc",
-    test: "vitest --run --coverage",
-    prepack: "cp ../../README.md ./README.md",
-    postpack: "rm -f ./README.md"
-  },
-  peerDependencies: {
-    typescript: "^5.0.2"
-  },
-  devDependencies: {
-    "@types/micromatch": "^4.0.7",
-    "@types/node": "^20.14.9",
-    "@types/pluralize": "^0.0.33",
-    "@types/serialize-javascript": "^5.0.4",
-    "@vitest/coverage-v8": "^1.5.0",
-    tsup: "^8.0.2",
-    tsx: "^4.1.1",
-    typescript: "^5.4.5",
-    vitest: "^1.5.0"
-  },
-  dependencies: {
-    "@parcel/watcher": "^2.4.1",
-    esbuild: "^0.21.4",
-    "fast-glob": "^3.3.2",
-    "gray-matter": "^4.0.3",
-    micromatch: "^4.0.7",
-    pluralize: "^8.0.0",
-    "serialize-javascript": "^6.0.2",
-    yaml: "^2.4.1",
-    zod: "^3.22.5"
-  }
-};
-
-// src/configurationReader.ts
-var import_node_fs = require("fs");
-var import_node_crypto = require("crypto");
-var ConfigurationError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-var importPathPlugin = {
-  name: "import-path",
-  setup(build2) {
-    build2.onResolve({ filter: /^\@content-collections\/core$/ }, () => {
-      return { path: import_node_path.default.join(__dirname, "index.ts"), external: true };
-    });
-  }
-};
-var defaultConfigName = "content-collection-config.mjs";
-function resolveCacheDir(config, options) {
-  if (options.cacheDir) {
-    return options.cacheDir;
-  }
-  return import_node_path.default.join(import_node_path.default.dirname(config), ".content-collections", "cache");
-}
-var makeAllPackagesExternalPlugin = (configPath) => ({
-  name: "make-all-packages-external",
-  setup: (build2) => {
-    const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/;
-    build2.onResolve({ filter }, (args) => {
-      if (args.path.includes(configPath)) {
-        return { path: args.path, external: false };
-      }
-      return { path: args.path, external: true };
-    });
-  }
-});
-async function compile(configurationPath, outfile) {
-  const plugins = [makeAllPackagesExternalPlugin(configurationPath)];
-  if (process.env.NODE_ENV === "test") {
-    plugins.push(importPathPlugin);
-  }
-  await esbuild.build({
-    entryPoints: [configurationPath],
-    packages: "external",
-    external: [
-      ...Object.keys(package_default.dependencies),
-      "@content-collections/*"
-    ],
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    plugins,
-    outfile
-  });
-}
-function createConfigurationReader() {
-  return async (configurationPath, options = {
-    configName: defaultConfigName
-  }) => {
-    if (!(0, import_node_fs.existsSync)(configurationPath)) {
-      throw new ConfigurationError(
-        "Read",
-        `configuration file ${configurationPath} does not exist`
-      );
-    }
-    const cacheDir = resolveCacheDir(configurationPath, options);
-    await import_promises.default.mkdir(cacheDir, { recursive: true });
-    const outfile = import_node_path.default.join(cacheDir, options.configName);
-    try {
-      await compile(configurationPath, outfile);
-    } catch (error) {
-      throw new ConfigurationError(
-        "Compile",
-        `configuration file ${configurationPath} is invalid: ${error}`
-      );
-    }
-    const module2 = await import(`file://${import_node_path.default.resolve(outfile)}?x=${Date.now()}`);
-    const hash = (0, import_node_crypto.createHash)("sha256");
-    hash.update(await import_promises.default.readFile(outfile, "utf-8"));
-    const checksum = hash.digest("hex");
-    return {
-      ...module2.default,
-      path: configurationPath,
-      generateTypes: true,
-      checksum
-    };
-  };
-}
-
-// src/collector.ts
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_promises2 = require("fs/promises");
-var import_path = __toESM(require("path"), 1);
-
-// src/parser.ts
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-var import_yaml = require("yaml");
-function frontmatterParser(fileContent) {
-  const { data, content } = (0, import_gray_matter.default)(fileContent, {
-    engines: {
-      yaml: {
-        parse: import_yaml.parse,
-        stringify: import_yaml.stringify
-      }
-    }
-  });
-  return {
-    ...data,
-    content: content.trim()
-  };
-}
-var parsers = {
-  frontmatter: {
-    hasContent: true,
-    parse: frontmatterParser
-  },
-  json: {
-    hasContent: false,
-    parse: JSON.parse
-  },
-  yaml: {
-    hasContent: false,
-    parse: import_yaml.parse
-  }
-};
-
-// 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 (0, import_promises2.readFile)(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 = import_path.default.join(baseDirectory, collection.directory, filePath);
-    const file = await read(absolutePath);
-    if (!file) {
-      return null;
-    }
-    try {
-      const data = parsers[collection.parser].parse(file);
-      return {
-        data,
-        path: filePath
-      };
-    } catch (error) {
-      emitter.emit("collector:parse-error", {
-        filePath: import_path.default.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 = import_path.default.join(baseDirectory, collection.directory);
-    const filePaths = await (0, import_fast_glob.default)(collection.include, {
-      cwd: collectionDirectory,
-      onlyFiles: true,
-      absolute: false,
-      ignore: createIgnorePattern(collection)
-    });
-    const promises = filePaths.map(
-      (filePath) => collectFile(collection, 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/writer.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_pluralize2 = __toESM(require("pluralize"), 1);
-
-// src/serializer.ts
-var import_zod2 = __toESM(require("zod"), 1);
-var import_serialize_javascript = __toESM(require("serialize-javascript"), 1);
-var literalSchema = import_zod2.default.union([
-  // json
-  import_zod2.default.string(),
-  import_zod2.default.number(),
-  import_zod2.default.boolean(),
-  import_zod2.default.null(),
-  // serializable-javascript
-  import_zod2.default.undefined(),
-  import_zod2.default.date(),
-  import_zod2.default.map(import_zod2.default.unknown(), import_zod2.default.unknown()),
-  import_zod2.default.set(import_zod2.default.unknown()),
-  import_zod2.default.bigint()
-]);
-var schema = import_zod2.default.lazy(
-  () => import_zod2.default.union([literalSchema, import_zod2.default.array(schema), import_zod2.default.record(schema)])
-);
-var extension = "js";
-var serializableSchema = import_zod2.default.record(schema);
-function serialize(value) {
-  const serializedValue = (0, import_serialize_javascript.default)(value, {
-    space: 2,
-    unsafe: true,
-    ignoreFunction: true
-  });
-  return `export default ${serializedValue};`;
-}
-
-// src/writer.ts
-function createArrayConstName(name) {
-  let suffix = name.charAt(0).toUpperCase() + name.slice(1);
-  return "all" + (0, import_pluralize2.default)(suffix);
-}
-async function createDataFile(directory, collection) {
-  const dataPath = import_node_path2.default.join(
-    directory,
-    `${createArrayConstName(collection.name)}.${extension}`
-  );
-  await import_promises3.default.writeFile(
-    dataPath,
-    serialize(collection.documents.map((doc) => doc.document))
-  );
-}
-function createDataFiles(directory, collections) {
-  return Promise.all(
-    collections.map((collection) => createDataFile(directory, collection))
-  );
-}
-async function createJavaScriptFile(directory, configuration) {
-  const collections = configuration.collections.map(
-    ({ name }) => createArrayConstName(name)
-  );
-  let content = `// generated by content-collections at ${/* @__PURE__ */ new Date()}
-
-`;
-  for (const name of collections) {
-    content += `import ${name} from "./${name}.${extension}";
-`;
-  }
-  content += "\n";
-  content += "export { " + collections.join(", ") + " };\n";
-  await import_promises3.default.writeFile(import_node_path2.default.join(directory, "index.js"), content, "utf-8");
-}
-function createImportPath(directory, target) {
-  let importPath = import_node_path2.default.posix.join(
-    ...import_node_path2.default.relative(directory, target).split(import_node_path2.default.sep)
-  );
-  if (!importPath.startsWith(".")) {
-    importPath = "./" + importPath;
-  }
-  return importPath;
-}
-async function createTypeDefinitionFile(directory, configuration) {
-  if (!configuration.generateTypes) {
-    return;
-  }
-  const importPath = createImportPath(directory, configuration.path);
-  let content = `import configuration from "${importPath}";
-import { GetTypeByName } from "@content-collections/core";
-`;
-  const collections = configuration.collections;
-  for (const collection of collections) {
-    content += `
-`;
-    content += `export type ${collection.typeName} = GetTypeByName<typeof configuration, "${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 createWriter(directory) {
-  await import_promises3.default.mkdir(directory, { recursive: true });
-  return {
-    createJavaScriptFile: (configuration) => createJavaScriptFile(directory, configuration),
-    createTypeDefinitionFile: (configuration) => createTypeDefinitionFile(directory, configuration),
-    createDataFiles: (collections) => createDataFiles(directory, collections)
-  };
-}
-
-// src/transformer.ts
-var import_node_path3 = require("path");
-var import_zod3 = require("zod");
-var TransformError = class extends Error {
-  type;
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-  }
-};
-function createPath(path7, ext) {
-  let p = path7.slice(0, -ext.length);
-  if (p.endsWith("/index")) {
-    p = p.slice(0, -6);
-  }
-  return p;
-}
-function createTransformer(emitter, cacheManager) {
-  function createSchema(parserName, schema2) {
-    const parser = parsers[parserName];
-    if (!parser.hasContent) {
-      return import_zod3.z.object(schema2);
-    }
-    return import_zod3.z.object({
-      content: import_zod3.z.string(),
-      ...schema2
-    });
-  }
-  async function parseFile(collection, file) {
-    const { data, path: path7 } = file;
-    const schema2 = createSchema(collection.parser, collection.schema);
-    let parsedData = await schema2.safeParseAsync(data);
-    if (!parsedData.success) {
-      emitter.emit("transformer:validation-error", {
-        collection,
-        file,
-        error: new TransformError("Validation", parsedData.error.message)
-      });
-      return null;
-    }
-    const ext = (0, import_node_path3.extname)(path7);
-    let extension2 = ext;
-    if (extension2.startsWith(".")) {
-      extension2 = extension2.slice(1);
-    }
-    const document = {
-      ...parsedData.data,
-      _meta: {
-        filePath: path7,
-        fileName: (0, import_node_path3.basename)(path7),
-        directory: (0, import_node_path3.dirname)(path7),
-        extension: extension2,
-        path: createPath(path7, ext)
-      }
-    };
-    return {
-      document
-    };
-  }
-  async function parseCollection(collection) {
-    const promises = collection.files.map(
-      (file) => parseFile(collection, file)
-    );
-    return {
-      ...collection,
-      documents: (await Promise.all(promises)).filter(isDefined)
-    };
-  }
-  function createContext(collections, collection, cache) {
-    return {
-      documents: (collection2) => {
-        const resolved = collections.find((c) => c.name === collection2.name);
-        if (!resolved) {
-          throw new TransformError(
-            "Configuration",
-            `Collection ${collection2.name} not found, do you have registered it in your configuration?`
-          );
-        }
-        return resolved.documents.map((doc) => doc.document);
-      },
-      collection: {
-        name: collection.name,
-        directory: collection.directory
-      },
-      cache: cache.cacheFn
-    };
-  }
-  async function transformCollection(collections, collection) {
-    if (collection.transform) {
-      const docs = [];
-      for (const doc of collection.documents) {
-        const cache = cacheManager.cache(
-          collection.name,
-          doc.document._meta.path
-        );
-        const context = createContext(collections, collection, cache);
-        try {
-          const document = await collection.transform(doc.document, context);
-          docs.push({
-            ...doc,
-            document
-          });
-          await cache.tidyUp();
-        } catch (error) {
-          if (error instanceof TransformError) {
-            emitter.emit("transformer:error", {
-              collection,
-              error
-            });
-          } else {
-            emitter.emit("transformer:error", {
-              collection,
-              error: new TransformError("Transform", String(error))
-            });
-          }
-        }
-      }
-      await cacheManager.flush();
-      return docs;
-    }
-    return collection.documents;
-  }
-  async function validateDocuments(collection, documents) {
-    const docs = [];
-    for (const doc of documents) {
-      let parsedData = await serializableSchema.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) {
-      const documents = await transformCollection(collections, collection);
-      collection.documents = await validateDocuments(collection, documents);
-    }
-    return collections;
-  };
-}
-
-// src/synchronizer.ts
-var import_micromatch = __toESM(require("micromatch"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollections(filePath) {
-    const resolvedFilePath = import_node_path4.default.resolve(filePath);
-    return collections.filter((collection) => {
-      return resolvedFilePath.startsWith(
-        import_node_path4.default.resolve(baseDirectory, collection.directory)
-      );
-    });
-  }
-  function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = import_node_path4.default.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = import_node_path4.default.resolve(filePath);
-    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith("/")) {
-      relativePath = relativePath.slice(1);
-    }
-    return relativePath;
-  }
-  function resolve(filePath) {
-    const collections2 = findCollections(filePath);
-    return collections2.map((collection) => {
-      const relativePath = createRelativePath(collection.directory, filePath);
-      return {
-        collection,
-        relativePath
-      };
-    }).filter(({ collection, relativePath }) => {
-      return import_micromatch.default.isMatch(relativePath, collection.include, {
-        ignore: collection.exclude
-      });
-    });
-  }
-  function deleted(filePath) {
-    const resolvedCollections = resolve(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 = resolve(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/builder.ts
-var import_node_path6 = __toESM(require("path"), 1);
-
-// src/watcher.ts
-var watcher = __toESM(require("@parcel/watcher"), 1);
-async function createWatcher(emitter, paths, sync, build2) {
-  const onChange = async (error, events) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-    let rebuild = false;
-    for (const event of events) {
-      if (await sync(event.type, event.path)) {
-        emitter.emit("watcher:file-changed", {
-          filePath: event.path,
-          modification: event.type
-        });
-        rebuild = true;
-      }
-    }
-    if (rebuild) {
-      await build2();
-    }
-  };
-  const subscriptions = await Promise.all(
-    paths.map((path7) => watcher.subscribe(path7, onChange))
-  );
-  return {
-    unsubscribe: async () => {
-      await Promise.all(
-        subscriptions.map((subscription) => subscription.unsubscribe())
-      );
-      return;
-    }
-  };
-}
-
-// src/events.ts
-var import_node_events = require("events");
-function isEventWithError(event) {
-  return typeof event === "object" && event !== null && "error" in event;
-}
-function createEmitter() {
-  const emitter = new import_node_events.EventEmitter();
-  function on(key, listener) {
-    emitter.on(key, listener);
-  }
-  function emit(key, event) {
-    emitter.emit(key, event);
-    if (isEventWithError(event)) {
-      emitter.emit("_error", {
-        ...event,
-        _event: key
-      });
-    }
-    emitter.emit("_all", {
-      ...event,
-      _event: key
-    });
-  }
-  return {
-    on,
-    emit
-  };
-}
-
-// src/cache.ts
-var import_node_path5 = __toESM(require("path"), 1);
-var import_promises4 = require("fs/promises");
-var import_node_fs2 = require("fs");
-var import_node_crypto2 = require("crypto");
-function createKey(config, input) {
-  return (0, import_node_crypto2.createHash)("sha256").update(config).update(JSON.stringify(input)).digest("hex");
-}
-async function createCacheDirectory(directory) {
-  const cacheDirectory = import_node_path5.default.join(directory, ".content-collections", "cache");
-  if (!(0, import_node_fs2.existsSync)(cacheDirectory)) {
-    await (0, import_promises4.mkdir)(cacheDirectory, { recursive: true });
-  }
-  return cacheDirectory;
-}
-function fileName(input) {
-  return input.replace(/[^a-z0-9]/gi, "_").toLowerCase();
-}
-async function createCacheManager(baseDirectory, configChecksum) {
-  const cacheDirectory = await createCacheDirectory(baseDirectory);
-  let mapping = {};
-  const mappingPath = (0, import_node_path5.join)(cacheDirectory, "mapping.json");
-  if ((0, import_node_fs2.existsSync)(mappingPath)) {
-    mapping = JSON.parse(await (0, import_promises4.readFile)(mappingPath, "utf-8"));
-  }
-  async function flush() {
-    await (0, import_promises4.writeFile)(mappingPath, JSON.stringify(mapping));
-  }
-  function cache(collection, file) {
-    const directory = (0, import_node_path5.join)(
-      cacheDirectory,
-      fileName(collection),
-      fileName(file)
-    );
-    let collectionMapping = mapping[collection];
-    if (!collectionMapping) {
-      collectionMapping = {};
-      mapping[collection] = collectionMapping;
-    }
-    let fileMapping = collectionMapping[file];
-    if (!fileMapping) {
-      fileMapping = [];
-      collectionMapping[file] = fileMapping;
-    }
-    let newFileMapping = [];
-    const cacheFn = async (input, fn) => {
-      const key = createKey(configChecksum, input);
-      newFileMapping.push(key);
-      const filePath = (0, import_node_path5.join)(directory, `${key}.cache`);
-      if (fileMapping?.includes(key) || newFileMapping.includes(key)) {
-        if ((0, import_node_fs2.existsSync)(filePath)) {
-          return JSON.parse(await (0, import_promises4.readFile)(filePath, "utf-8"));
-        }
-      }
-      const output = await fn(input);
-      if (!(0, import_node_fs2.existsSync)(directory)) {
-        await (0, import_promises4.mkdir)(directory, { recursive: true });
-      }
-      await (0, import_promises4.writeFile)(filePath, JSON.stringify(output));
-      return output;
-    };
-    const tidyUp = async () => {
-      const filesToDelete = fileMapping?.filter((key) => !newFileMapping.includes(key)) || [];
-      for (const key of filesToDelete) {
-        const filePath = (0, import_node_path5.join)(directory, `${key}.cache`);
-        if ((0, import_node_fs2.existsSync)(filePath)) {
-          await (0, import_promises4.unlink)(filePath);
-        }
-      }
-      if (collectionMapping) {
-        collectionMapping[file] = newFileMapping;
-      }
-    };
-    return {
-      cacheFn,
-      tidyUp
-    };
-  }
-  return {
-    cache,
-    flush
-  };
-}
-
-// src/builder.ts
-function resolveOutputDir(baseDirectory, options) {
-  if (options.outputDir) {
-    return options.outputDir;
-  }
-  return import_node_path6.default.join(baseDirectory, ".content-collections", "generated");
-}
-async function createBuilder(configurationPath, options = {
-  configName: defaultConfigName
-}) {
-  const emitter = createEmitter();
-  const readConfiguration = createConfigurationReader();
-  const configuration = await readConfiguration(configurationPath, options);
-  const baseDirectory = import_node_path6.default.dirname(configurationPath);
-  const directory = resolveOutputDir(baseDirectory, options);
-  const collector = createCollector(emitter, baseDirectory);
-  const writer = await createWriter(directory);
-  const [resolved] = await Promise.all([
-    collector.collect(configuration.collections),
-    writer.createJavaScriptFile(configuration),
-    writer.createTypeDefinitionFile(configuration)
-  ]);
-  const synchronizer = createSynchronizer(
-    collector.collectFile,
-    resolved,
-    baseDirectory
-  );
-  const cacheManager = await createCacheManager(baseDirectory, configuration.checksum);
-  const transform = createTransformer(emitter, cacheManager);
-  async function sync(modification, filePath) {
-    if (modification === "delete") {
-      return synchronizer.deleted(filePath);
-    }
-    return synchronizer.changed(filePath);
-  }
-  async function build2() {
-    const startedAt = Date.now();
-    emitter.emit("builder:start", {
-      startedAt
-    });
-    const collections = await transform(resolved);
-    await writer.createDataFiles(collections);
-    const pendingOnSuccess = collections.filter((collection) => Boolean(collection.onSuccess)).map(
-      (collection) => collection.onSuccess?.(collection.documents.map((doc) => doc.document))
-    );
-    await Promise.all(pendingOnSuccess.filter(isDefined));
-    emitter.emit("builder:end", {
-      startedAt,
-      endedAt: Date.now()
-    });
-  }
-  async function watch() {
-    const paths = resolved.map(
-      (collection) => import_node_path6.default.join(baseDirectory, collection.directory)
-    );
-    const watcher2 = await createWatcher(emitter, paths, sync, build2);
-    return watcher2;
-  }
-  return {
-    sync,
-    build: build2,
-    watch,
-    on: emitter.on
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CollectError,
-  ConfigurationError,
-  TransformError,
-  createBuilder,
-  defineCollection,
-  defineConfig
-});

package/dist/index.d.cts

@@ -1,206 +0,0 @@
-import z, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
-import { parse } from 'yaml';
-
-type Parsers = typeof parsers;
-type Parser = keyof typeof parsers;
-declare function frontmatterParser(fileContent: string): {
-    content: string;
-};
-declare const parsers: {
-    readonly frontmatter: {
-        readonly hasContent: true;
-        readonly parse: typeof frontmatterParser;
-    };
-    readonly json: {
-        readonly hasContent: false;
-        readonly parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
-    };
-    readonly yaml: {
-        readonly hasContent: false;
-        readonly parse: typeof parse;
-    };
-};
-
-type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
-
-declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined, z.ZodDate, z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>, z.ZodBigInt]>;
-type Literal = z.infer<typeof literalSchema>;
-type SchemaType = Literal | {
-    [key: string]: SchemaType;
-} | 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.
-
-The following type is not valid:`;
-declare const serializableSchema: z.ZodRecord<z.ZodString, z.ZodType<SchemaType, z.ZodTypeDef, SchemaType>>;
-type Serializable = z.infer<typeof serializableSchema>;
-
-type Meta = {
-    filePath: string;
-    fileName: string;
-    directory: string;
-    path: string;
-    extension: string;
-};
-type WithContent = {
-    content: ZodString;
-};
-type AddContent<TShape extends ZodRawShape> = TShape extends {
-    content: ZodTypeAny;
-} ? 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$1.infer<ZodObject<GetShape<TParser, TShape>>> & {
-    _meta: Meta;
-};
-type Context = {
-    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
-    cache: CacheFn;
-    collection: {
-        name: string;
-        directory: string;
-    };
-};
-type Z = typeof z$1;
-type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser, TSchema, TTransformResult, TDocument> = {
-    name: TName;
-    parser?: TParser;
-    typeName?: string;
-    schema: (z: Z) => TShape;
-    transform?: (data: TSchema, context: Context) => TTransformResult;
-    directory: string;
-    include: string | string[];
-    exclude?: string | string[];
-    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
-};
-type Collection<TName extends string, TShape extends ZodRawShape, TParser extends Parser, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>, "schema"> & {
-    typeName: string;
-    schema: TShape;
-    parser: TParser;
-};
-type AnyCollection = Collection<any, ZodRawShape, Parser, any, any, any>;
-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 Serializable ? Collection<TName, TShape, TParser, TSchema, TTransformResult, 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;
-    cache?: Cache;
-};
-type AnyConfiguration = Configuration<Array<AnyCollection>>;
-declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
-
-type Modification = "create" | "update" | "delete";
-type Document = {
-    _meta: Meta;
-};
-type CollectionFile = {
-    data: {
-        content?: string;
-        [key: string]: unknown;
-    };
-    path: string;
-};
-type CollectionByName<TConfiguration extends AnyConfiguration> = {
-    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
-};
-type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, any, infer TDocument> ? TDocument : never;
-type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
-
-type CollectorEvents = {
-    "collector:read-error": {
-        filePath: string;
-        error: CollectError;
-    };
-    "collector:parse-error": {
-        filePath: string;
-        error: CollectError;
-    };
-};
-type ErrorType$2 = "Parse" | "Read";
-declare class CollectError extends Error {
-    type: ErrorType$2;
-    constructor(type: ErrorType$2, message: string);
-}
-
-type TransformerEvents = {
-    "transformer:validation-error": {
-        collection: AnyCollection;
-        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" | "Result";
-declare class TransformError extends Error {
-    type: ErrorType$1;
-    constructor(type: ErrorType$1, message: string);
-}
-
-type WatcherEvents = {
-    "watcher:file-changed": {
-        filePath: string;
-        modification: Modification;
-    };
-};
-
-type EventWithError = {
-    error: Error;
-};
-type SystemEvent = {
-    _event: string;
-};
-type ErrorEvent = EventWithError & SystemEvent;
-type Events = BuilderEvents & CollectorEvents & TransformerEvents & WatcherEvents;
-type SystemEvents = {
-    _error: ErrorEvent;
-    _all: SystemEvent;
-};
-
-type ErrorType = "Read" | "Compile";
-declare class ConfigurationError extends Error {
-    type: ErrorType;
-    constructor(type: ErrorType, message: string);
-}
-type Options$1 = {
-    configName: string;
-    cacheDir?: string;
-};
-
-type BuilderEvents = {
-    "builder:start": {
-        startedAt: number;
-    };
-    "builder:end": {
-        startedAt: number;
-        endedAt: number;
-    };
-};
-type Options = Options$1 & {
-    outputDir?: string;
-};
-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: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;
-    };
-}>;
-type Builder = Awaited<ReturnType<typeof createBuilder>>;
-
-export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, TransformError, createBuilder, defineCollection, defineConfig };