@content-collections/core 0.7.2 → 0.8.0

package/README.md

@@ -17,7 +17,7 @@ Transform your content into type-safe data collections. Eliminate the need for m
 - **Simple to use**:
   No need to manually fetch and parse your content anymore. Just import it and start using Content Collections. It provides a simple API, allowing you to concentrate on building your app.
 
-- **Tansformation**:
+- **Transformation**:
   Content Collections allows you to transform your content before it enters your app. You can use it to modify your content, join two collections or even fetch data from a server.
 
 ## Installation

package/dist/index.d.ts

@@ -3,17 +3,34 @@ export * from 'zod';
 
 type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
 
+declare const importSymbol: unique symbol;
+type Import<T> = {
+    [importSymbol]: true;
+    path: string;
+    name?: string;
+};
+type GetTypeOfImport<T> = T extends Import<infer U> ? U : never;
+declare function createDefaultImport<T>(path: string): Import<T>;
+declare function createNamedImport<T>(name: string, path: string): Import<T>;
+
 type Parsers = typeof parsers;
 type Parser = keyof typeof parsers;
 declare function parseYaml(content: string): any;
 declare function frontmatterParser(fileContent: string): {
     content: string;
 };
+declare function frontmatterOnlyParser(fileContent: string): {
+    [key: string]: any;
+};
 declare const parsers: {
     readonly frontmatter: {
         readonly hasContent: true;
         readonly parse: typeof frontmatterParser;
     };
+    readonly "frontmatter-only": {
+        readonly hasContent: false;
+        readonly parse: typeof frontmatterOnlyParser;
+    };
     readonly json: {
         readonly hasContent: false;
         readonly parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
@@ -86,7 +103,10 @@ 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 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 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, 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;
@@ -261,4 +281,4 @@ declare function createBuilder(configurationPath: string, options?: Options, emi
 }>;
 type Builder = Awaited<ReturnType<typeof createBuilder>>;
 
-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, defineCollection, defineConfig };
+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 };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/builder.ts
-import path8 from "node:path";
+import path9 from "node:path";
 
 // src/cache.ts
 import { createHash } from "node:crypto";
@@ -102,7 +102,7 @@ async function createCacheManager(baseDirectory, configChecksum) {
 
 // src/collector.ts
 import { readFile as readFile2 } from "fs/promises";
-import path2 from "path";
+import path3 from "node:path";
 import { glob } from "tinyglobby";
 
 // src/parser.ts
@@ -111,8 +111,8 @@ import { parse, stringify } from "yaml";
 function parseYaml(content) {
   return parse(content.trim());
 }
-function frontmatterParser(fileContent) {
-  const { data, content } = matter(fileContent, {
+function frontmatter(fileContent) {
+  return matter(fileContent, {
     engines: {
       yaml: {
         parse: parseYaml,
@@ -120,16 +120,27 @@ function frontmatterParser(fileContent) {
       }
     }
   });
+}
+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
@@ -143,6 +154,7 @@ var parsers = {
 // 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 });
@@ -156,17 +168,23 @@ function orderByPath(a, b) {
 function removeChildPaths(paths) {
   return Array.from(
     new Set(
-      paths.filter((path9) => {
+      paths.filter((path10) => {
         return !paths.some((otherPath) => {
-          if (path9 === otherPath) {
+          if (path10 === otherPath) {
             return false;
           }
-          return path9.startsWith(otherPath);
+          return path10.startsWith(otherPath);
         });
       })
     )
   );
 }
+function posixToNativePath(pathName) {
+  if (path2.sep !== path2.posix.sep) {
+    return pathName.replaceAll(path2.posix.sep, path2.sep);
+  }
+  return pathName;
+}
 
 // src/collector.ts
 var CollectError = class extends Error {
@@ -189,7 +207,7 @@ function createCollector(emitter, baseDirectory = ".") {
     }
   }
   async function collectFile(collection, filePath) {
-    const absolutePath = path2.join(
+    const absolutePath = path3.join(
       baseDirectory,
       collection.directory,
       filePath
@@ -206,7 +224,7 @@ function createCollector(emitter, baseDirectory = ".") {
       };
     } catch (error) {
       emitter.emit("collector:parse-error", {
-        filePath: path2.join(collection.directory, filePath),
+        filePath: path3.join(collection.directory, filePath),
         error: new CollectError("Parse", String(error))
       });
       return null;
@@ -223,7 +241,7 @@ function createCollector(emitter, baseDirectory = ".") {
     return void 0;
   }
   async function resolveCollection(collection) {
-    const collectionDirectory = path2.join(baseDirectory, collection.directory);
+    const collectionDirectory = path3.join(baseDirectory, collection.directory);
     const include = Array.isArray(collection.include) ? collection.include : [collection.include];
     const filePaths = await glob(include, {
       cwd: collectionDirectory,
@@ -232,7 +250,7 @@ function createCollector(emitter, baseDirectory = ".") {
       ignore: createIgnorePattern(collection)
     });
     const promises = filePaths.map(
-      (filePath) => collectFile(collection, filePath)
+      (filePath) => collectFile(collection, posixToNativePath(filePath))
     );
     const files = await Promise.all(promises);
     return {
@@ -253,23 +271,23 @@ function createCollector(emitter, baseDirectory = ".") {
 }
 
 // src/synchronizer.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import picomatch from "picomatch";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
   function findCollections(filePath) {
-    const resolvedFilePath = path3.resolve(filePath);
+    const resolvedFilePath = path4.resolve(filePath);
     return collections.filter((collection) => {
       return resolvedFilePath.startsWith(
-        path3.resolve(baseDirectory, collection.directory)
+        path4.resolve(baseDirectory, collection.directory)
       );
     });
   }
   function createRelativePath(collectionPath, filePath) {
-    const resolvedCollectionPath = path3.resolve(baseDirectory, collectionPath);
-    const resolvedFilePath = path3.resolve(filePath);
+    const resolvedCollectionPath = path4.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path4.resolve(filePath);
     let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
-    if (relativePath.startsWith(path3.sep)) {
-      relativePath = relativePath.slice(path3.sep.length);
+    if (relativePath.startsWith(path4.sep)) {
+      relativePath = relativePath.slice(path4.sep.length);
     }
     return relativePath;
   }
@@ -342,6 +360,27 @@ import { z as z2 } from "zod";
 // src/serializer.ts
 import serializeJs from "serialize-javascript";
 import z from "zod";
+
+// src/import.ts
+var importSymbol = Symbol("import");
+function isImport(value) {
+  return value && value[importSymbol];
+}
+function createDefaultImport(path10) {
+  return {
+    [importSymbol]: true,
+    path: path10
+  };
+}
+function createNamedImport(name, path10) {
+  return {
+    [importSymbol]: true,
+    path: path10,
+    name
+  };
+}
+
+// src/serializer.ts
 var literalSchema = z.union([
   // json
   z.string(),
@@ -360,13 +399,39 @@ var schema = z.lazy(
 );
 var extension = "js";
 var serializableSchema = z.record(schema);
+function createImport(imp, variableName) {
+  const variableDeclaration = imp.name ? `{ ${imp.name} as ${variableName} }` : variableName;
+  return `import ${variableDeclaration} from "${imp.path}";
+`;
+}
 function serialize(value) {
-  const serializedValue = serializeJs(value, {
+  let serializedValue = "";
+  let counter = 0;
+  function handleImports(item) {
+    if (item instanceof Object) {
+      Object.entries(item).forEach(([key, value2]) => {
+        if (isImport(value2)) {
+          counter++;
+          const variableName = `__v_${counter}`;
+          serializedValue += createImport(value2, variableName);
+          item[key] = variableName;
+        } else if (value2 instanceof Object) {
+          handleImports(value2);
+        }
+      });
+    }
+  }
+  value.forEach(handleImports);
+  serializedValue += "\n";
+  const js = serializeJs(value, {
     space: 2,
     unsafe: true,
     ignoreFunction: true
+  }).replace(/"__v_(\d+)"/g, (_, index) => {
+    return `__v_${index}`;
   });
-  return `export default ${serializedValue};`;
+  serializedValue += "export default " + js;
+  return serializedValue;
 }
 
 // src/transformer.ts
@@ -377,8 +442,8 @@ var TransformError = class extends Error {
     this.type = type;
   }
 };
-function createPath(path9, ext) {
-  let p = path9.slice(0, -ext.length);
+function createPath(path10, ext) {
+  let p = path10.slice(0, -ext.length);
   if (p.endsWith("/index")) {
     p = p.slice(0, -6);
   }
@@ -396,7 +461,7 @@ function createTransformer(emitter, cacheManager) {
     });
   }
   async function parseFile(collection, file) {
-    const { data, path: path9 } = file;
+    const { data, path: path10 } = file;
     const schema2 = createSchema(collection.parser, collection.schema);
     let parsedData = await schema2.safeParseAsync(data);
     if (!parsedData.success) {
@@ -407,7 +472,7 @@ function createTransformer(emitter, cacheManager) {
       });
       return null;
     }
-    const ext = extname(path9);
+    const ext = extname(path10);
     let extension2 = ext;
     if (extension2.startsWith(".")) {
       extension2 = extension2.slice(1);
@@ -415,11 +480,11 @@ function createTransformer(emitter, cacheManager) {
     const document = {
       ...parsedData.data,
       _meta: {
-        filePath: path9,
-        fileName: basename(path9),
-        directory: dirname(path9),
+        filePath: path10,
+        fileName: basename(path10),
+        directory: dirname(path10),
         extension: extension2,
-        path: createPath(path9, ext)
+        path: createPath(path10, ext)
       }
     };
     return {
@@ -525,14 +590,14 @@ function createTransformer(emitter, cacheManager) {
 
 // src/writer.ts
 import fs from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 import pluralize2 from "pluralize";
 function createArrayConstName(name) {
   let suffix = name.charAt(0).toUpperCase() + name.slice(1);
   return "all" + pluralize2(suffix);
 }
 async function createDataFile(directory, collection) {
-  const dataPath = path4.join(
+  const dataPath = path5.join(
     directory,
     `${createArrayConstName(collection.name)}.${extension}`
   );
@@ -559,11 +624,11 @@ async function createJavaScriptFile(directory, configuration) {
   }
   content += "\n";
   content += "export { " + collections.join(", ") + " };\n";
-  await fs.writeFile(path4.join(directory, "index.js"), content, "utf-8");
+  await fs.writeFile(path5.join(directory, "index.js"), content, "utf-8");
 }
 function createImportPath(directory, target) {
-  let importPath = path4.posix.join(
-    ...path4.relative(directory, target).split(path4.sep)
+  let importPath = path5.posix.join(
+    ...path5.relative(directory, target).split(path5.sep)
   );
   if (!importPath.startsWith(".")) {
     importPath = "./" + importPath;
@@ -591,7 +656,7 @@ import { GetTypeByName } from "@content-collections/core";
   }
   content += "\n";
   content += "export {};\n";
-  await fs.writeFile(path4.join(directory, "index.d.ts"), content, "utf-8");
+  await fs.writeFile(path5.join(directory, "index.d.ts"), content, "utf-8");
 }
 async function createWriter(directory) {
   await fs.mkdir(directory, { recursive: true });
@@ -674,7 +739,7 @@ async function build({
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import fs3 from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // ../../node_modules/.pnpm/bundle-require@5.0.0_esbuild@0.21.4/node_modules/bundle-require/dist/index.js
 import {
@@ -683,7 +748,7 @@ import {
 } from "esbuild";
 
 // ../../node_modules/.pnpm/load-tsconfig@0.2.5/node_modules/load-tsconfig/dist/index.js
-import path5 from "path";
+import path6 from "path";
 import fs2 from "fs";
 import { createRequire } from "module";
 var singleComment = Symbol("singleComment");
@@ -780,10 +845,10 @@ function jsoncParse(data) {
   }
 }
 var req = true ? createRequire(import.meta.url) : __require;
-var findUp = (name, startDir, stopDir = path5.parse(startDir).root) => {
+var findUp = (name, startDir, stopDir = path6.parse(startDir).root) => {
   let dir = startDir;
   while (dir !== stopDir) {
-    const file = path5.join(dir, name);
+    const file = path6.join(dir, name);
     if (fs2.existsSync(file))
       return file;
     if (!file.endsWith(".json")) {
@@ -791,17 +856,17 @@ var findUp = (name, startDir, stopDir = path5.parse(startDir).root) => {
       if (fs2.existsSync(fileWithExt))
         return fileWithExt;
     }
-    dir = path5.dirname(dir);
+    dir = path6.dirname(dir);
   }
   return null;
 };
 var resolveTsConfigFromFile = (cwd, filename) => {
-  if (path5.isAbsolute(filename))
+  if (path6.isAbsolute(filename))
     return fs2.existsSync(filename) ? filename : null;
   return findUp(filename, cwd);
 };
 var resolveTsConfigFromExtends = (cwd, name) => {
-  if (path5.isAbsolute(name))
+  if (path6.isAbsolute(name))
     return fs2.existsSync(name) ? name : null;
   if (name.startsWith("."))
     return findUp(name, cwd);
@@ -810,14 +875,14 @@ var resolveTsConfigFromExtends = (cwd, name) => {
 };
 var loadTsConfigInternal = (dir = process.cwd(), name = "tsconfig.json", isExtends = false) => {
   var _a, _b;
-  dir = path5.resolve(dir);
+  dir = path6.resolve(dir);
   const id = isExtends ? resolveTsConfigFromExtends(dir, name) : resolveTsConfigFromFile(dir, name);
   if (!id)
     return null;
   const data = jsoncParse(fs2.readFileSync(id, "utf-8"));
-  const configDir = path5.dirname(id);
+  const configDir = path6.dirname(id);
   if ((_a = data.compilerOptions) == null ? void 0 : _a.baseUrl) {
-    data.compilerOptions.baseUrl = path5.join(
+    data.compilerOptions.baseUrl = path6.join(
       configDir,
       data.compilerOptions.baseUrl
     );
@@ -880,21 +945,26 @@ function tsconfigResolvePaths(configPath) {
   }
   return tsconfig?.data?.compilerOptions?.paths || {};
 }
+var NON_NODE_MODULE_RE = /^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/;
 function createExternalsPlugin(configPath) {
   const resolvedPaths = tsconfigResolvePaths(configPath);
   const resolvePatterns = tsconfigPathsToRegExp(resolvedPaths);
   return {
     name: "external-packages",
     setup: (build4) => {
-      const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/;
-      build4.onResolve({ filter }, ({ path: path9, kind }) => {
-        if (match(path9, resolvePatterns)) {
+      build4.onResolve({ filter: /.*/ }, ({ path: path10, kind }) => {
+        if (match(path10, resolvePatterns)) {
           if (kind === "dynamic-import") {
-            return { path: path9, external: true };
+            return { path: path10, external: true };
           }
           return;
         }
-        return { path: path9, external: true };
+        if (!NON_NODE_MODULE_RE.test(path10)) {
+          return {
+            path: path10,
+            external: true
+          };
+        }
       });
     }
   };
@@ -938,7 +1008,7 @@ function resolveCacheDir(config, options) {
   if (options.cacheDir) {
     return options.cacheDir;
   }
-  return path6.join(path6.dirname(config), ".content-collections", "cache");
+  return path7.join(path7.dirname(config), ".content-collections", "cache");
 }
 function createConfigurationReader() {
   return async (configurationPath, options = {
@@ -952,17 +1022,17 @@ function createConfigurationReader() {
     }
     const cacheDir = resolveCacheDir(configurationPath, options);
     await fs3.mkdir(cacheDir, { recursive: true });
-    const outfile = path6.join(cacheDir, options.configName);
+    const outfile = path7.join(cacheDir, options.configName);
     try {
       const configurationPaths = await compile(configurationPath, outfile);
-      const module = await import(`file://${path6.resolve(outfile)}?x=${Date.now()}`);
+      const module = await import(`file://${path7.resolve(outfile)}?x=${Date.now()}`);
       const hash = createHash2("sha256");
       hash.update(await fs3.readFile(outfile, "utf-8"));
       const checksum = hash.digest("hex");
       return {
         ...module.default,
         path: configurationPath,
-        inputPaths: configurationPaths.map((p) => path6.resolve(p)),
+        inputPaths: configurationPaths.map((p) => path7.resolve(p)),
         generateTypes: true,
         checksum
       };
@@ -1006,7 +1076,7 @@ function createEmitter() {
 
 // src/watcher.ts
 import * as watcher from "@parcel/watcher";
-import path7, { dirname as dirname3, resolve } from "node:path";
+import path8, { dirname as dirname3, resolve } from "node:path";
 async function createWatcher(emitter, baseDirectory, configuration, sync) {
   const onChange = async (error, events) => {
     if (error) {
@@ -1021,10 +1091,10 @@ async function createWatcher(emitter, baseDirectory, configuration, sync) {
     }
   };
   const paths = removeChildPaths([
-    ...configuration.collections.map((collection) => path7.join(baseDirectory, collection.directory)).map((p) => resolve(p)),
+    ...configuration.collections.map((collection) => path8.join(baseDirectory, collection.directory)).map((p) => resolve(p)),
     ...configuration.inputPaths.map((p) => dirname3(p))
   ]);
-  const subscriptions = (await Promise.all(paths.map((path9) => watcher.subscribe(path9, onChange)))).filter(isDefined);
+  const subscriptions = (await Promise.all(paths.map((path10) => watcher.subscribe(path10, onChange)))).filter(isDefined);
   emitter.emit("watcher:subscribed", {
     paths
   });
@@ -1049,7 +1119,7 @@ function resolveOutputDir(baseDirectory, options) {
   if (options.outputDir) {
     return options.outputDir;
   }
-  return path8.join(baseDirectory, ".content-collections", "generated");
+  return path9.join(baseDirectory, ".content-collections", "generated");
 }
 var ConfigurationReloadError = class extends Error {
   constructor(message) {
@@ -1060,7 +1130,7 @@ async function createBuilder(configurationPath, options = {
   configName: defaultConfigName
 }, emitter = createEmitter()) {
   const readConfiguration = createConfigurationReader();
-  const baseDirectory = path8.dirname(configurationPath);
+  const baseDirectory = path9.dirname(configurationPath);
   const outputDirectory = resolveOutputDir(baseDirectory, options);
   emitter.emit("builder:created", {
     createdAt: Date.now(),
@@ -1182,6 +1252,8 @@ export {
   ConfigurationReloadError,
   TransformError,
   createBuilder,
+  createDefaultImport,
+  createNamedImport,
   defineCollection,
   defineConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-collections/core",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,11 +24,11 @@
     "@types/picomatch": "^3.0.1",
     "@types/pluralize": "^0.0.33",
     "@types/serialize-javascript": "^5.0.4",
-    "@vitest/coverage-v8": "^2.1.1",
+    "@vitest/coverage-v8": "^2.1.5",
     "tsup": "^8.2.4",
-    "tsx": "^4.1.1",
+    "tsx": "^4.19.2",
     "typescript": "^5.5.4",
-    "vitest": "^2.1.1"
+    "vitest": "^2.1.5"
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",