@nuasite/cli 0.41.0 → 0.42.0

package/dist/index.js

@@ -22551,6 +22551,7 @@ function parseConfigSource(source, sourcePath) {
   const bindings = new Map;
   const collectionDecls = new Map;
   const exportMap = new Map;
+  const inlineCollections = new Map;
   for (const stmt of ast.program.body) {
     const varDecl = stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : stmt.type === "VariableDeclaration" ? stmt : null;
     if (!varDecl)
@@ -22570,6 +22571,11 @@ function parseConfigSource(source, sourcePath) {
             continue;
           if (prop.value.type === "Identifier") {
             exportMap.set(prop.value.name, key);
+          } else if (prop.value.type === "CallExpression" && isDefineCollectionCallee(prop.value.callee)) {
+            const inlineArg = prop.value.arguments[0];
+            if (inlineArg?.type === "ObjectExpression") {
+              inlineCollections.set(key, inlineArg);
+            }
           }
         }
         continue;
@@ -22582,19 +22588,46 @@ function parseConfigSource(source, sourcePath) {
       }
     }
   }
+  const collectionObjects = new Map(inlineCollections);
   for (const [varName, collectionName] of exportMap) {
     const decl = collectionDecls.get(varName);
-    if (!decl)
-      continue;
+    if (decl)
+      collectionObjects.set(collectionName, decl);
+  }
+  for (const [collectionName, decl] of collectionObjects) {
+    const loaderProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "loader");
+    const loaderOptions = loaderProperty ? extractGlobLoaderOptions(loaderProperty.value, bindings) : {};
+    const loaderPattern = loaderOptions.pattern;
+    const loaderBase = loaderOptions.base;
     const schemaProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "schema");
-    if (!schemaProperty)
+    if (!schemaProperty) {
+      if (!loaderPattern)
+        continue;
+      result.set(collectionName, {
+        name: collectionName,
+        fields: [],
+        loaderPattern,
+        loaderBase
+      });
       continue;
+    }
     const schemaObject = unwrapSchemaToObject(schemaProperty.value, bindings);
-    if (!schemaObject)
+    if (!schemaObject) {
+      if (!loaderPattern)
+        continue;
+      result.set(collectionName, {
+        name: collectionName,
+        fields: [],
+        loaderPattern,
+        loaderBase
+      });
       continue;
+    }
     result.set(collectionName, {
       name: collectionName,
-      fields: parseSchemaFields(schemaObject, bindings)
+      fields: parseSchemaFields(schemaObject, bindings),
+      loaderPattern,
+      loaderBase
     });
   }
   return result;
@@ -22609,6 +22642,43 @@ function propertyKeyName(key) {
     return key.value;
   return null;
 }
+function extractGlobLoaderOptions(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type !== "CallExpression")
+    return {};
+  if (!isGlobCallee(resolved.callee))
+    return {};
+  const arg = resolved.arguments[0];
+  if (!arg)
+    return {};
+  const options = resolveExpression(arg, bindings);
+  if (options.type !== "ObjectExpression")
+    return {};
+  const result = {};
+  for (const prop of options.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    if (key !== "pattern" && key !== "base")
+      continue;
+    const value = extractStaticString(prop.value, bindings);
+    if (value !== undefined)
+      result[key] = value;
+  }
+  return result;
+}
+function extractStaticString(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type === "StringLiteral")
+    return resolved.value;
+  if (resolved.type === "TemplateLiteral" && resolved.expressions.length === 0) {
+    return resolved.quasis[0]?.value.cooked ?? resolved.quasis[0]?.value.raw;
+  }
+  return;
+}
+function isGlobCallee(callee) {
+  return callee.type === "Identifier" && callee.name === "glob";
+}
 function unwrapSchemaToObject(node, bindings) {
   const resolved = resolveExpression(node, bindings);
   if (resolved.type === "ArrowFunctionExpression" || resolved.type === "FunctionExpression") {
@@ -23013,7 +23083,7 @@ function collectFieldObservations(fieldMap, data, totalEntries) {
     obs.presentCount++;
   }
 }
-function buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, entryCount, extra) {
+function assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, entryCount, extra) {
   for (const obs of fieldMap.values()) {
     obs.totalEntries = entryCount;
   }
@@ -23031,6 +23101,68 @@ function buildCollectionDefinition(collectionName, contentDir, fieldMap, entryIn
     ...extra
   };
 }
+function getCollectionSourceBasePath(basePath, collectionName, contentDir) {
+  const projectRoot = getProjectRoot();
+  const defaultContentDir = path2.isAbsolute(contentDir) ? contentDir : path2.join(projectRoot, contentDir);
+  const defaultCollectionPath = path2.join(defaultContentDir, collectionName);
+  if (path2.resolve(basePath) === path2.resolve(defaultCollectionPath)) {
+    return path2.join(contentDir, collectionName);
+  }
+  const relativeBase = path2.relative(projectRoot, basePath);
+  if (relativeBase && !relativeBase.startsWith("..") && !path2.isAbsolute(relativeBase)) {
+    return relativeBase;
+  }
+  return basePath;
+}
+async function buildCollectionDefinition(basePath, sources, collectionName, contentDir) {
+  if (sources.length === 0)
+    return null;
+  const sourceBasePath = getCollectionSourceBasePath(basePath, collectionName, contentDir);
+  const hasMd = sources.some((s) => s.relPath.endsWith(".md"));
+  const fileExtension = hasMd ? "md" : "mdx";
+  const fieldMap = new Map;
+  const allDirectives = {};
+  const entryInfos = [];
+  let hasDraft = false;
+  const fileContents = await Promise.all(sources.map((s) => fs2.readFile(path2.join(basePath, s.relPath), "utf-8")));
+  for (let i = 0;i < sources.length; i++) {
+    const source = sources[i];
+    const content = fileContents[i];
+    const frontmatter = parseFrontmatter2(content);
+    const directives = parseFieldDirectives(content);
+    for (const [key, value] of Object.entries(directives)) {
+      if (!allDirectives[key]) {
+        allDirectives[key] = value;
+      }
+    }
+    const entryInfo = {
+      slug: source.slug,
+      sourcePath: path2.join(sourceBasePath, source.relPath)
+    };
+    if (frontmatter) {
+      if (typeof frontmatter.title === "string") {
+        entryInfo.title = frontmatter.title;
+      }
+      if (typeof frontmatter.draft === "boolean" && frontmatter.draft) {
+        entryInfo.draft = true;
+      }
+      entryInfo.data = frontmatter;
+    }
+    entryInfos.push(entryInfo);
+    if (!frontmatter)
+      continue;
+    if (frontmatter.draft === true)
+      hasDraft = true;
+    collectFieldObservations(fieldMap, frontmatter, sources.length);
+  }
+  const def = assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+    path: sourceBasePath,
+    supportsDraft: hasDraft,
+    fileExtension
+  });
+  assignFieldMetadata(def.fields, allDirectives);
+  return def;
+}
 async function scanCollection(collectionPath, collectionName, contentDir) {
   try {
     const dirEntries = await fs2.readdir(collectionPath, { withFileTypes: true });
@@ -23064,49 +23196,71 @@ async function scanCollection(collectionPath, collectionName, contentDir) {
     }
     if (sources.length === 0)
       return null;
-    const hasMd = sources.some((s) => s.relPath.endsWith(".md"));
-    const fileExtension = hasMd ? "md" : "mdx";
-    const fieldMap = new Map;
-    const allDirectives = {};
-    const entryInfos = [];
-    let hasDraft = false;
-    const fileContents = await Promise.all(sources.map((s) => fs2.readFile(path2.join(collectionPath, s.relPath), "utf-8")));
-    for (let i = 0;i < sources.length; i++) {
-      const source = sources[i];
-      const content = fileContents[i];
-      const frontmatter = parseFrontmatter2(content);
-      const directives = parseFieldDirectives(content);
-      for (const [key, value] of Object.entries(directives)) {
-        if (!allDirectives[key]) {
-          allDirectives[key] = value;
-        }
+    return await buildCollectionDefinition(collectionPath, sources, collectionName, contentDir);
+  } catch {
+    return null;
+  }
+}
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/")
+          i++;
+      } else {
+        re += "[^/]*";
       }
-      const entryInfo = {
-        slug: source.slug,
-        sourcePath: path2.join(contentDir, collectionName, source.relPath)
-      };
-      if (frontmatter) {
-        if (typeof frontmatter.title === "string") {
-          entryInfo.title = frontmatter.title;
-        }
-        if (typeof frontmatter.draft === "boolean" && frontmatter.draft) {
-          entryInfo.draft = true;
-        }
-        entryInfo.data = frontmatter;
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      if (end === -1) {
+        re += "\\{";
+      } else {
+        const opts = glob.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&"));
+        re += `(?:${opts.join("|")})`;
+        i = end;
       }
-      entryInfos.push(entryInfo);
-      if (!frontmatter)
-        continue;
-      if (frontmatter.draft === true)
-        hasDraft = true;
-      collectFieldObservations(fieldMap, frontmatter, sources.length);
+    } else if (".+^$()|[]\\".includes(c)) {
+      re += `\\${c}`;
+    } else {
+      re += c;
     }
-    const def = buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
-      supportsDraft: hasDraft,
-      fileExtension
-    });
-    assignFieldMetadata(def.fields, allDirectives);
-    return def;
+  }
+  return new RegExp(`^${re}$`);
+}
+async function walkFiles(dir, prefix = "") {
+  let dirEntries;
+  try {
+    dirEntries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of dirEntries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith("."))
+      continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      out.push(...await walkFiles(path2.join(dir, entry.name), rel));
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+async function scanGlobCollection(collectionName, baseRel, pattern, contentDir) {
+  try {
+    const absBase = path2.join(getProjectRoot(), baseRel);
+    const matcher = globToRegExp(pattern);
+    const sources = (await walkFiles(absBase)).filter((rel) => (rel.endsWith(".md") || rel.endsWith(".mdx")) && matcher.test(rel)).map((rel) => ({ slug: rel.replace(/\.(md|mdx)$/, ""), relPath: rel }));
+    if (sources.length === 0)
+      return null;
+    return await buildCollectionDefinition(absBase, sources, collectionName, contentDir);
   } catch {
     return null;
   }
@@ -23422,7 +23576,7 @@ async function scanDataCollection(collectionPath, collectionName, contentDir) {
       });
       collectFieldObservations(fieldMap, data, sources.length);
     }
-    return buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+    return assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
       type: "data",
       fileExtension: ext
     });
@@ -23446,6 +23600,20 @@ async function scanCollections(contentDir = "src/content") {
     await Promise.all(scanPromises);
   } catch {}
   const parsed = await parseContentConfig();
+  for (const [collectionName, parsedCollection] of parsed) {
+    if (collections[collectionName])
+      continue;
+    if (!parsedCollection.loaderBase || !parsedCollection.loaderPattern)
+      continue;
+    const definition = await scanGlobCollection(collectionName, parsedCollection.loaderBase, parsedCollection.loaderPattern, contentDir);
+    if (!definition)
+      continue;
+    const baseName = parsedCollection.loaderBase.replace(/[/\\]+$/, "").split(/[/\\]/).pop();
+    if (baseName && baseName !== collectionName && collections[baseName]) {
+      definition.parentCollection = baseName;
+    }
+    collections[collectionName] = definition;
+  }
   applyParsedConfig(collections, parsed);
   detectReferenceFields(collections, parsed);
   detectDerivedHrefFields(collections);
@@ -24830,7 +24998,8 @@ async function handleCreateMarkdown(request) {
     return { success: false, error: `Invalid file extension "${ext}". Allowed: ${allowedExtensions.join(", ")}` };
   }
   const isData = ext === "json" || ext === "yaml" || ext === "yml";
-  const filePath = `src/content/${collection}/${normalizedSlug}.${ext}`;
+  const layout = isData ? "flat" : await detectCollectionMarkdownLayout(collection);
+  const filePath = layout === "index" ? `src/content/${collection}/${normalizedSlug}/index.${ext}` : `src/content/${collection}/${normalizedSlug}.${ext}`;
   const fullPath = resolveAndValidatePath(filePath);
   let fileContent;
   if (isData) {
@@ -24918,6 +25087,68 @@ async function handleRenameMarkdown(request) {
 function isDataFile(filePath) {
   return filePath.endsWith(".json") || filePath.endsWith(".yaml") || filePath.endsWith(".yml");
 }
+async function detectCollectionMarkdownLayout(collection) {
+  const existingLayout = await inferLayoutFromExistingEntries(collection);
+  if (existingLayout)
+    return existingLayout;
+  const configLayout = await inferLayoutFromContentConfig(collection);
+  if (configLayout)
+    return configLayout;
+  return "flat";
+}
+async function inferLayoutFromExistingEntries(collection) {
+  const collectionPath = path9.join(getProjectRoot(), "src", "content", collection);
+  let dirEntries;
+  try {
+    dirEntries = await fs9.readdir(collectionPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let flatCount = 0;
+  let indexCount = 0;
+  const flatSlugs = new Set;
+  for (const entry of dirEntries) {
+    if (!entry.isFile())
+      continue;
+    const match = entry.name.match(/^(.+)\.(md|mdx)$/);
+    if (!match)
+      continue;
+    flatCount++;
+    flatSlugs.add(match[1]);
+  }
+  const subdirs = dirEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && !entry.name.startsWith("."));
+  const indexLookups = await Promise.all(subdirs.map(async (dir) => {
+    if (flatSlugs.has(dir.name))
+      return false;
+    for (const ext of ["md", "mdx"]) {
+      try {
+        await fs9.access(path9.join(collectionPath, dir.name, `index.${ext}`));
+        return true;
+      } catch {}
+    }
+    return false;
+  }));
+  indexCount = indexLookups.filter(Boolean).length;
+  if (indexCount > flatCount)
+    return "index";
+  if (flatCount > 0)
+    return "flat";
+  return null;
+}
+async function inferLayoutFromContentConfig(collection) {
+  try {
+    const parsed = await parseContentConfig();
+    const pattern = parsed.get(collection)?.loaderPattern;
+    if (!pattern)
+      return null;
+    return isIndexStyleGlobPattern(pattern) ? "index" : "flat";
+  } catch {
+    return null;
+  }
+}
+function isIndexStyleGlobPattern(pattern) {
+  return pattern.includes("index.{") || pattern.includes("*/index") || pattern.includes("**/index");
+}
 function parseFrontmatter3(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -25027,6 +25258,7 @@ function ensureMdxImports(content, filePath, componentDefinitions) {
 var import_yaml2, YAML_DATE_PATTERN;
 var init_markdown_ops = __esm(() => {
   init_config();
+  init_content_config_ast();
   init_utils2();
   import_yaml2 = __toESM(require_dist(), 1);
   YAML_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/;
@@ -32787,6 +33019,7 @@ var init_tailwind_colors = __esm(() => {
 
 // ../cms/src/html-processor.ts
 var init_html_processor = __esm(() => {
+  init_config();
   init_seo_processor();
   init_tailwind_colors();
   init_utils2();