@content-collections/core 0.7.1 → 0.7.3

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
@@ -143,6 +143,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 +157,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 +196,7 @@ function createCollector(emitter, baseDirectory = ".") {
     }
   }
   async function collectFile(collection, filePath) {
-    const absolutePath = path2.join(
+    const absolutePath = path3.join(
       baseDirectory,
       collection.directory,
       filePath
@@ -206,7 +213,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 +230,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 +239,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 +260,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;
   }
@@ -377,8 +384,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 +403,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 +414,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 +422,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 +532,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 +566,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 +598,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 +681,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 +690,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 +787,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 +798,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 +817,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 +887,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 +950,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 +964,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 +1018,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 +1033,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 +1061,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 +1072,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(),

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@content-collections/core",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "files": [
@@ -24,11 +24,11 @@
     "@types/picomatch": "^3.0.1",
     "@types/pluralize": "^0.0.33",
     "@types/serialize-javascript": "^5.0.4",
-    "@vitest/coverage-v8": "^2.0.5",
+    "@vitest/coverage-v8": "^2.1.3",
     "tsup": "^8.2.4",
     "tsx": "^4.1.1",
     "typescript": "^5.5.4",
-    "vitest": "^2.0.5"
+    "vitest": "^2.1.3"
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",