@content-collections/core 0.3.0 → 0.3.1

package/dist/index.js

@@ -44,9 +44,9 @@ import path from "path";
 // package.json
 var package_default = {
   name: "@content-collections/core",
-  version: "0.3.0",
+  version: "0.3.1",
   type: "module",
-  main: "dist/index.cjs",
+  main: "dist/index.js",
   types: "./dist/index.d.ts",
   exports: {
     "./package.json": "./package.json",
@@ -121,6 +121,7 @@ async function compile(configurationPath, outfile) {
   }
   await esbuild.build({
     entryPoints: [configurationPath],
+    packages: "external",
     external: [
       ...Object.keys(package_default.dependencies),
       "@content-collections/*"

package/package.json

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

package/dist/apidoc.d.ts

@@ -1,186 +0,0 @@
-import { z } from 'zod';
-import { ZodObject } from 'zod';
-import { ZodRawShape } from 'zod';
-import { ZodString } from 'zod';
-import { ZodTypeAny } from 'zod';
-
-declare type AddContent<TShape extends ZodRawShape> = TShape extends {
-    content: ZodTypeAny;
-} ? TShape : TShape & WithContent;
-
-export declare type AnyCollection = Collection<any, ZodRawShape, any, any, any>;
-
-export declare type AnyConfiguration = Configuration<Array<AnyCollection>>;
-
-export declare type Builder = Awaited<ReturnType<typeof createBuilder>>;
-
-export declare type BuilderEvents = {
-    "builder:start": {
-        startedAt: number;
-    };
-    "builder:end": {
-        startedAt: number;
-        endedAt: number;
-    };
-};
-
-export declare class CollectError extends Error {
-    type: ErrorType$2;
-    constructor(type: ErrorType$2, message: string);
-}
-
-export declare type Collection<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>, "schema"> & {
-    typeName: string;
-    schema: TShape;
-};
-
-declare type CollectionByName<TConfiguration extends AnyConfiguration> = {
-    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
-};
-
-declare type CollectionFile = {
-    data: {
-        content: string;
-        [key: string]: unknown;
-    };
-    path: string;
-};
-
-export declare type CollectionRequest<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = {
-    /**
-     * The name of the collection
-     */
-    name: TName;
-    /**
-     * The name of the generated TypeScript type.
-     * If the typeName is undefined the pluralized name of the collection will be used.
-     */
-    typeName?: string;
-    schema: (z: Z) => TShape;
-    transform?: (context: Context, data: TSchema) => TTransformResult;
-    directory: string | string[];
-    include: string | string[];
-    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
-};
-
-declare type CollectorEvents = {
-    "collector:read-error": {
-        filePath: string;
-        error: CollectError;
-    };
-    "collector:parse-error": {
-        filePath: string;
-        error: CollectError;
-    };
-};
-
-export declare type Configuration<TCollections extends Array<AnyCollection>> = {
-    collections: TCollections;
-};
-
-export declare class ConfigurationError extends Error {
-    type: ErrorType;
-    constructor(type: ErrorType, message: string);
-}
-
-export declare type Context = {
-    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["schema"]>>;
-};
-
-export declare function createBuilder(configurationPath: string, options?: Options): Promise<{
-    sync: (modification: Modification, filePath: string) => Promise<boolean>;
-    build: () => Promise<void>;
-    watch: () => Promise<{
-        unsubscribe: () => Promise<void>;
-    }>;
-    on: {
-        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:error" | "watcher:file-changed">(key: TKey, listener: (event: Events[TKey]) => void): void;
-        <TKey_1 extends "_error" | "_all">(key: TKey_1, listener: (event: SystemEvents[TKey_1]) => void): void;
-    };
-}>;
-
-export declare function defineCollection<TName extends string, TShape extends ZodRawShape, TSchema = Schema<TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TSchema, TTransformResult, TDocument>;
-
-export declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
-
-declare type ErrorEvent = EventWithError & SystemEvent;
-
-declare type ErrorType$1 = "Validation" | "Configuration" | "Transform";
-
-declare type ErrorType$2 = "Parse" | "Read";
-
-declare type ErrorType = "Read" | "Compile";
-
-declare type Events = BuilderEvents & CollectorEvents & TransformerEvents & WatcherEvents;
-
-declare type EventWithError = {
-    error: Error;
-};
-
-declare type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, infer TDocument> ? TDocument : never;
-
-export declare type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
-
-export declare type Meta = {
-    filePath: string;
-    fileName: string;
-    directory: string;
-    path: string;
-    extension: string;
-};
-
-export declare type Modification = "create" | "update" | "delete";
-
-declare type Options$1 = {
-    configName: string;
-    cacheDir?: string;
-};
-
-declare type Options = Options$1 & {
-    outputDir?: string;
-};
-
-export declare type Schema<TShape extends ZodRawShape> = z.infer<ZodObject<AddContent<TShape>>> & {
-    _meta: Meta;
-};
-
-declare type SystemEvent = {
-    _event: string;
-};
-
-declare type SystemEvents = {
-    _error: ErrorEvent;
-    _all: SystemEvent;
-};
-
-declare type TransformerEvents = {
-    "transformer:validation-error": {
-        collection: AnyCollection;
-        file: CollectionFile;
-        error: TransformError;
-    };
-    "transformer:error": {
-        collection: AnyCollection;
-        error: TransformError;
-    };
-};
-
-export declare class TransformError extends Error {
-    type: ErrorType$1;
-    constructor(type: ErrorType$1, message: string);
-}
-
-declare type WatcherEvents = {
-    "watcher:file-changed": {
-        filePath: string;
-        modification: Modification;
-    };
-};
-
-declare type WithContent = {
-    content: ZodString;
-};
-
-declare type Z = typeof z;
-
-export { }

package/dist/index.cjs

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

package/dist/index.d.cts

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