@kosmojs/dev 0.0.10 → 0.0.20

package/pkg/base-plugin/routes.js

@@ -1,819 +0,0 @@
-// src/base-plugin/routes.ts
-import {
-  defaults as defaults2
-} from "@kosmojs/devlib";
-
-// src/base-plugin/routes/resolve.ts
-import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
-import crc3 from "crc/crc32";
-import picomatch from "picomatch";
-import { glob } from "tinyglobby";
-import {
-  defaults,
-  pathResolver as pathResolver2,
-  pathTokensFactory,
-  render,
-  renderToFile
-} from "@kosmojs/devlib";
-
-// src/base-plugin/ast.ts
-import { resolve } from "node:path";
-import crc from "crc/crc32";
-import { flattener } from "tfusion";
-import {
-  Project,
-  SyntaxKind
-} from "ts-morph";
-import { HTTPMethods } from "@kosmojs/api";
-var createProject = (opts) => new Project(opts);
-var resolveRouteSignature = async (route, opts) => {
-  const {
-    sourceFile = createProject().addSourceFileAtPath(route.fileFullpath)
-  } = { ...opts };
-  const [typeDeclarations, referencedFiles] = extractTypeDeclarations(
-    sourceFile,
-    opts
-  );
-  const defaultExport = extractDefaultExport(sourceFile);
-  const paramsRefinements = defaultExport ? extractParamsRefinements(defaultExport) : void 0;
-  const methods = defaultExport ? extractRouteMethods(defaultExport, route) : [];
-  const payloadTypes = methods.flatMap((e) => {
-    return e.payloadType ? [e.payloadType] : [];
-  });
-  const responseTypes = methods.flatMap((e) => {
-    return e.responseType ? [e.responseType] : [];
-  });
-  return {
-    typeDeclarations,
-    paramsRefinements,
-    methods: methods.map((e) => e.method),
-    payloadTypes,
-    responseTypes,
-    referencedFiles
-  };
-};
-var extractDefaultExport = (sourceFile) => {
-  const [defaultExport] = sourceFile.getExportAssignments().flatMap((exportAssignment) => {
-    if (exportAssignment.isExportEquals()) {
-      return [];
-    }
-    const callExpression = exportAssignment.getExpression();
-    return callExpression.isKind(SyntaxKind.CallExpression) ? [callExpression] : [];
-  });
-  return defaultExport;
-};
-var extractParamsRefinements = (callExpression) => {
-  const [firstGeneric] = extractGenerics(callExpression);
-  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
-    return;
-  }
-  const tupleElements = firstGeneric.node.getElements();
-  if (!tupleElements?.length) {
-    return;
-  }
-  return tupleElements.map((node, index) => {
-    return {
-      index,
-      text: node.getText()
-    };
-  });
-};
-var extractRouteMethods = (callExpression, route) => {
-  const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
-  if (!funcDeclaration) {
-    return [];
-  }
-  const arrayLiteralExpression = funcDeclaration.getFirstChildByKind(
-    SyntaxKind.ArrayLiteralExpression
-  );
-  if (!arrayLiteralExpression) {
-    return [];
-  }
-  const callExpressions = [];
-  for (const e of arrayLiteralExpression.getChildrenOfKind(
-    SyntaxKind.CallExpression
-  )) {
-    const name = e.getExpression().getText();
-    if (HTTPMethods[name]) {
-      callExpressions.push([e, name]);
-    }
-  }
-  const methods = [];
-  const skipValidationFilter = (e) => /@skip-validation/.test(e);
-  for (const [callExpression2, method] of callExpressions) {
-    const [payloadGeneric, responseGeneric] = extractGenerics(callExpression2);
-    const payloadText = payloadGeneric?.node ? payloadGeneric.node.getChildren().length === 0 ? "{}" : payloadGeneric.node.getFullText() : void 0;
-    const responseText = responseGeneric?.node.getText();
-    const responseType = responseText ? {
-      id: ["ResponseT", crc(route.importName + method)].join(""),
-      method,
-      skipValidation: responseGeneric?.comments ? responseGeneric.comments.some(skipValidationFilter) : false,
-      text: ["never", "object"].includes(responseText) ? "{}" : responseText,
-      resolvedType: void 0
-    } : void 0;
-    const payloadType = payloadText ? {
-      id: ["PayloadT", crc(route.importName + method)].join(""),
-      responseTypeId: responseType?.id,
-      method,
-      skipValidation: payloadGeneric?.comments ? payloadGeneric.comments.some(skipValidationFilter) : false,
-      isOptional: payloadText ? payloadText === "{}" || route.optionalParams : true,
-      text: payloadText,
-      resolvedType: void 0
-    } : void 0;
-    methods.push({
-      method,
-      payloadType,
-      responseType
-    });
-  }
-  return methods;
-};
-var extractTypeDeclarations = (sourceFile, opts) => {
-  const declarations = [];
-  const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
-  for (const declaration of sourceFile.getImportDeclarations()) {
-    const modulePath = declaration.getModuleSpecifierValue();
-    const path = /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath;
-    const typeOnlyDeclaration = declaration.isTypeOnly();
-    const defaultImport = typeOnlyDeclaration ? declaration.getDefaultImport() : void 0;
-    if (defaultImport) {
-      const name = defaultImport.getText();
-      const text = `import type ${name} from "${path}";`;
-      declarations.push({
-        importDeclaration: {
-          name,
-          path
-        },
-        text
-      });
-      if (referencedFiles) {
-        referencedFiles.push(...getReferencedFiles(defaultImport));
-      }
-    }
-    for (const namedImport of declaration.getNamedImports()) {
-      if (namedImport.isTypeOnly() || typeOnlyDeclaration) {
-        const nameNode = namedImport.getNameNode();
-        const name = nameNode.getText();
-        const alias = namedImport.getAliasNode()?.getText();
-        const nameText = alias ? `${name} as ${alias}` : name;
-        declarations.push({
-          importDeclaration: {
-            name,
-            alias,
-            path
-          },
-          text: `import type { ${nameText} } from "${path}";`
-        });
-        if (referencedFiles) {
-          if (nameNode.isKind(SyntaxKind.Identifier)) {
-            referencedFiles.push(...getReferencedFiles(nameNode));
-          }
-        }
-      }
-    }
-  }
-  for (const declaration of sourceFile.getTypeAliases()) {
-    const name = declaration.getName();
-    const text = declaration.getFullText().trim();
-    declarations.push({
-      typeAliasDeclaration: { name },
-      text
-    });
-  }
-  for (const declaration of sourceFile.getInterfaces()) {
-    const name = declaration.getName();
-    const text = declaration.getFullText().trim();
-    declarations.push({
-      interfaceDeclaration: { name },
-      text
-    });
-  }
-  for (const declaration of sourceFile.getEnums()) {
-    const name = declaration.getName();
-    const text = declaration.getFullText().trim();
-    declarations.push({
-      enumDeclaration: { name },
-      text
-    });
-  }
-  for (const declaration of sourceFile.getExportDeclarations()) {
-    const typeOnlyDeclaration = declaration.isTypeOnly();
-    const modulePath = declaration.getModuleSpecifierValue();
-    const path = modulePath ? /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath : void 0;
-    for (const namedExport of declaration.getNamedExports()) {
-      if (namedExport.isTypeOnly() || typeOnlyDeclaration) {
-        const nameNode = namedExport.getNameNode();
-        const name = nameNode.getText();
-        const alias = namedExport.getAliasNode()?.getText();
-        const nameText = alias ? `${name} as ${alias}` : name;
-        declarations.push({
-          exportDeclaration: {
-            name,
-            alias: alias ?? name,
-            path
-          },
-          text: path ? `export type { ${nameText} } from "${path}";` : `export type { ${nameText} };`
-        });
-        if (referencedFiles) {
-          if (nameNode.isKind(SyntaxKind.Identifier)) {
-            referencedFiles.push(...getReferencedFiles(nameNode));
-          }
-        }
-      }
-    }
-  }
-  return referencedFiles ? [declarations, [...new Set(referencedFiles)]] : [declarations];
-};
-var getReferencedFiles = (importIdentifier) => {
-  const declarations = importIdentifier?.getSymbol()?.getAliasedSymbol()?.getDeclarations() || [];
-  return declarations.flatMap((e) => {
-    const sourceFile = e.getSourceFile();
-    return sourceFile ? [sourceFile.getFilePath()] : [];
-  });
-};
-var extractGenerics = (callExpression) => {
-  return callExpression.getTypeArguments().map((node) => {
-    return {
-      node,
-      comments: node.getLeadingCommentRanges().map((range) => range.getText().trim())
-    };
-  });
-};
-var typeResolverFactory = ({ appRoot }) => {
-  const project = createProject({
-    tsConfigFilePath: resolve(appRoot, "tsconfig.json"),
-    skipAddingFilesFromTsConfig: true
-  });
-  const literalTypesResolver = (literalTypes, options) => {
-    const sourceFile = project.createSourceFile(
-      `${crc(literalTypes)}-${Date.now()}.ts`,
-      literalTypes,
-      { overwrite: true }
-    );
-    const resolvedTypes = flattener(project, sourceFile, {
-      ...options,
-      stripComments: true
-    });
-    project.removeSourceFile(sourceFile);
-    return resolvedTypes;
-  };
-  return {
-    getSourceFile: (fileFullpath) => {
-      return project.getSourceFile(fileFullpath) || project.addSourceFileAtPath(fileFullpath);
-    },
-    refreshSourceFile: async (fileFullpath) => {
-      const sourceFile = project.getSourceFile(fileFullpath);
-      if (sourceFile) {
-        await sourceFile.refreshFromFileSystem();
-      }
-    },
-    literalTypesResolver
-  };
-};
-
-// src/base-plugin/cache.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve as resolve2 } from "node:path";
-import crc2 from "crc/crc32";
-import self from "@kosmojs/dev/package.json" with { type: "json" };
-import { pathExists, pathResolver } from "@kosmojs/devlib";
-var cacheFactory = (route, {
-  appRoot,
-  sourceFolder,
-  extraContext
-}) => {
-  const cacheFile = pathResolver({
-    appRoot,
-    sourceFolder
-  }).resolve("apiLibDir", dirname(route.file), "cache.json");
-  const getCache = async (opt) => {
-    if (await pathExists(cacheFile)) {
-      try {
-        const cache = JSON.parse(await readFile(cacheFile, "utf8"));
-        return opt?.validate ? validateCache(cache) : cache;
-      } catch (_e) {
-      }
-    }
-    return void 0;
-  };
-  const persistCache = async ({
-    referencedFiles: _referencedFiles,
-    ...rest
-  }) => {
-    const hash = await generateFileHash(route.fileFullpath, {
-      ...extraContext
-    });
-    const referencedFiles = {};
-    for (const file of _referencedFiles) {
-      referencedFiles[
-        // Strip project root to ensure cached paths are relative
-        // and portable across environments (CI, local, etc.)
-        file.replace(`${appRoot}/`, "")
-      ] = await generateFileHash(file);
-    }
-    const cache = { ...rest, hash, referencedFiles };
-    await mkdir(dirname(cacheFile), { recursive: true });
-    await writeFile(cacheFile, JSON.stringify(cache, null, 2), "utf8");
-    return cache;
-  };
-  const validateCache = async (cache) => {
-    if (!cache?.hash) {
-      return;
-    }
-    if (!cache.typeDeclarations || !cache.referencedFiles) {
-      return;
-    }
-    const hash = await generateFileHash(route.fileFullpath, {
-      ...extraContext
-    });
-    if (!identicalHashSum(cache.hash, hash)) {
-      return;
-    }
-    for (const [file, hash2] of Object.entries(cache.referencedFiles)) {
-      if (!identicalHashSum(hash2, await generateFileHash(resolve2(appRoot, file)))) {
-        return;
-      }
-    }
-    return cache;
-  };
-  return {
-    getCache,
-    validateCache,
-    persistCache
-  };
-};
-var generateFileHash = async (file, extraContext) => {
-  let fileContent;
-  try {
-    fileContent = await readFile(file, "utf8");
-  } catch (_e) {
-    return 0;
-  }
-  return fileContent ? crc2(
-    JSON.stringify({
-      ...extraContext,
-      [self.cacheVersion]: fileContent
-    })
-  ) : 0;
-};
-var identicalHashSum = (a, b) => {
-  return a === b;
-};
-
-// src/base-plugin/templates/resolved-types.hbs
-var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
-
-// src/base-plugin/templates/types.hbs
-var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}:{{#if isRest}} Array<{{/if}}\n    {{#if refinement}}{{refinement.text}}{{else}}string{{/if}}\n  {{#if isRest}}>{{/if}}\n  {{/each}}\n};\n\n{{#each payloadTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n\n{{#each responseTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n';
-
-// src/base-plugin/routes/resolve.ts
-var API_INDEX_BASENAME = "index";
-var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
-var API_USE_BASENAME = "use";
-var API_USE_PATTERN = `${API_USE_BASENAME}.ts`;
-var PAGE_INDEX_BASENAME = "index";
-var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue}`;
-var PAGE_LAYOUT_BASENAME = "layout";
-var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue}`;
-var ROUTE_FILE_PATTERNS = [
-  // match index files in api dir
-  `${defaults.apiDir}/**/${API_INDEX_PATTERN}`,
-  // match use files in api dir
-  `${defaults.apiDir}/**/${API_USE_PATTERN}`,
-  // match index files in pages dir
-  `${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
-  // match layout files in pages dir
-  `${defaults.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
-];
-var scanRoutes = async ({
-  appRoot,
-  sourceFolder
-}) => {
-  return glob(ROUTE_FILE_PATTERNS, {
-    cwd: resolve3(appRoot, sourceFolder),
-    absolute: true,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    ignore: [
-      // ignore top-level matches, routes resides in folders, even index route
-      `${defaults.apiDir}/${API_INDEX_PATTERN}`,
-      `${defaults.apiDir}/${API_USE_PATTERN}`,
-      `${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`,
-      `${defaults.pagesDir}/${PAGE_LAYOUT_PATTERN}`
-    ]
-  });
-};
-var isRouteFile = (file, {
-  appRoot,
-  sourceFolder
-}) => {
-  const [_sourceFolder, folder, ...rest] = resolve3(appRoot, file).replace(`${appRoot}/`, "").split("/");
-  if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
-    return;
-  }
-  return picomatch.isMatch(join(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : void 0;
-};
-var isApiRoute = (file) => {
-  return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
-};
-var isApiUse = (file) => {
-  return picomatch.matchBase(file, `**/${API_USE_PATTERN}`);
-};
-var isPageRoute = (file) => {
-  return picomatch.matchBase(file, `**/${PAGE_INDEX_PATTERN}`);
-};
-var isPageLayout = (file) => {
-  return picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
-};
-var createRouteEntry = (_file, {
-  appRoot,
-  sourceFolder
-}) => {
-  const resolvedPaths = isRouteFile(_file, { appRoot, sourceFolder });
-  if (!resolvedPaths) {
-    return;
-  }
-  const [folder, file] = resolvedPaths;
-  const fileFullpath = join(appRoot, sourceFolder, folder, file);
-  const pathTokens = pathTokensFactory(dirname2(file));
-  const name = pathTokens.map((e) => e.orig).join("/");
-  const importFile = file;
-  const importName = `${importFile.replace(/\W+/g, "_")}_${crc3(importFile)}`;
-  return {
-    name,
-    folder,
-    file,
-    fileFullpath,
-    pathTokens,
-    importFile,
-    importName
-  };
-};
-var pageLayoutResolverFactory = () => {
-  return (entry) => {
-    const { name } = entry;
-    const handler = async () => {
-      return {
-        kind: "pageLayout",
-        entry
-      };
-    };
-    return { name, handler };
-  };
-};
-var pageRouteResolverFactory = () => {
-  return (entry) => {
-    const {
-      name,
-      folder,
-      file,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = entry;
-    const handler = async () => {
-      const entry2 = {
-        name,
-        pathTokens,
-        params: {
-          schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
-        },
-        folder,
-        file,
-        fileFullpath,
-        importFile,
-        importName
-      };
-      return {
-        kind: "pageRoute",
-        entry: entry2
-      };
-    };
-    return { name, handler };
-  };
-};
-var apiUseResolverFactory = () => {
-  return (entry) => {
-    const { name } = entry;
-    const handler = async () => {
-      return {
-        kind: "apiUse",
-        entry
-      };
-    };
-    return { name, handler };
-  };
-};
-var apiRouteResolverFactory = (pluginOptions) => {
-  const {
-    appRoot,
-    sourceFolder,
-    generators = [],
-    formatters = [],
-    refineTypeName
-  } = pluginOptions;
-  let resolveTypes = false;
-  for (const { options } of generators) {
-    if (options?.resolveTypes) {
-      resolveTypes = true;
-    }
-  }
-  const {
-    //
-    literalTypesResolver,
-    getSourceFile,
-    refreshSourceFile
-  } = typeResolverFactory(pluginOptions);
-  return (entry) => {
-    const {
-      name,
-      file,
-      folder,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = entry;
-    const handler = async (updatedFile) => {
-      const paramsSchema = pathTokens.flatMap((e) => {
-        return e.param ? [e.param] : [];
-      });
-      const optionalParams = paramsSchema.length ? !paramsSchema.some((e) => e.isRequired) : true;
-      const { getCache, persistCache } = cacheFactory(
-        { file, fileFullpath, importName },
-        {
-          appRoot,
-          sourceFolder,
-          extraContext: { resolveTypes }
-        }
-      );
-      let cache = await getCache({ validate: true });
-      if (!cache) {
-        if (updatedFile === fileFullpath) {
-          await refreshSourceFile(fileFullpath);
-        }
-        const {
-          typeDeclarations,
-          paramsRefinements,
-          methods,
-          payloadTypes,
-          responseTypes,
-          referencedFiles = []
-        } = await resolveRouteSignature(
-          { importName, fileFullpath, optionalParams },
-          {
-            withReferencedFiles: true,
-            sourceFile: getSourceFile(fileFullpath),
-            relpathResolver(path) {
-              return join(sourceFolder, defaults.apiDir, dirname2(file), path);
-            }
-          }
-        );
-        const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
-          if (text === "number") {
-            const param = paramsSchema.at(index);
-            return param ? [param.name] : [];
-          }
-          return [];
-        }) : [];
-        const typesFile = pathResolver2({ appRoot, sourceFolder }).resolve(
-          "apiLibDir",
-          dirname2(file),
-          "types.ts"
-        );
-        const params = {
-          id: ["ParamsT", crc3(name)].join(""),
-          schema: paramsSchema,
-          resolvedType: void 0
-        };
-        const typesFileContent = render(types_default, {
-          params,
-          paramsSchema: paramsSchema.map((param, index) => {
-            return {
-              ...param,
-              refinement: paramsRefinements?.at(index)
-            };
-          }),
-          typeDeclarations,
-          payloadTypes,
-          responseTypes
-        });
-        const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
-          overrides: [...payloadTypes, ...responseTypes].reduce(
-            (map, { id, skipValidation }) => {
-              if (skipValidation) {
-                map[id] = "never";
-              }
-              return map;
-            },
-            { [refineTypeName]: refineTypeName }
-          ),
-          withProperties: [params.id, ...payloadTypes.map((e) => e.id)],
-          formatters
-        }) : void 0;
-        await renderToFile(
-          typesFile,
-          resolvedTypes ? resolved_types_default : typesFileContent,
-          { resolvedTypes }
-        );
-        params.resolvedType = resolvedTypes?.find((e) => e.name === params.id);
-        cache = await persistCache({
-          params,
-          methods,
-          typeDeclarations,
-          numericParams,
-          // text was needed at writing types.ts file, dropping from cache
-          payloadTypes: payloadTypes.map(({ text, ...rest }) => {
-            return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
-            };
-          }),
-          responseTypes: responseTypes.map(({ text, ...rest }) => {
-            return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
-            };
-          }),
-          referencedFiles
-        });
-      }
-      const entry2 = {
-        name,
-        pathTokens,
-        params: cache.params,
-        numericParams: cache.numericParams,
-        optionalParams,
-        importName,
-        importFile,
-        folder,
-        file,
-        fileFullpath,
-        methods: cache.methods,
-        typeDeclarations: cache.typeDeclarations,
-        payloadTypes: cache.payloadTypes,
-        responseTypes: cache.responseTypes,
-        referencedFiles: Object.keys(cache.referencedFiles).map(
-          // expand referenced files path,
-          // they are stored as relative in cache
-          (e) => resolve3(appRoot, e)
-        )
-      };
-      return {
-        kind: "apiRoute",
-        entry: entry2
-      };
-    };
-    return { name, handler };
-  };
-};
-
-// src/base-plugin/routes/nesting.ts
-import { basename } from "node:path";
-import {
-  sortRoutes
-} from "@kosmojs/devlib";
-var nestedRoutesFactory = (routeEntries) => {
-  const entryStack = structuredClone(routeEntries).sort(sortRoutes);
-  const transformEntries = (entries, parent) => {
-    return [...new Set(entries.map((e) => e.name))].flatMap((name) => {
-      const nameEntries = entryStack.flatMap(({ fileFullpath, ...entry }) => {
-        return entry.name === name ? [entry] : [];
-      });
-      const index = nameEntries.find(
-        (e) => basename(e.file).startsWith(PAGE_INDEX_BASENAME)
-      );
-      const layout = nameEntries.find(
-        (e) => basename(e.file).startsWith(PAGE_LAYOUT_BASENAME)
-      );
-      if (index || layout) {
-        return [
-          {
-            index: index ? {
-              ...index,
-              pathTokens: index.pathTokens.slice(
-                parent?.pathTokens.length || 0
-              )
-            } : void 0,
-            layout: layout ? {
-              ...layout,
-              pathTokens: layout.pathTokens.slice(
-                parent?.pathTokens.length || 0
-              )
-            } : void 0,
-            parent: parent?.name,
-            children: transformEntries(
-              findDescendantEntries(index || layout),
-              index || layout
-            )
-          }
-        ];
-      }
-      return [];
-    });
-  };
-  const findDescendantEntries = ({
-    name,
-    pathTokens
-  }) => {
-    const potentialChildren = entryStack.filter((entry) => {
-      if (entry.pathTokens.length <= pathTokens.length) {
-        return false;
-      }
-      if (!entry.name.startsWith(`${name}/`)) {
-        return false;
-      }
-      return true;
-    });
-    return potentialChildren.filter((child) => {
-      const hasIntermediateRoute = potentialChildren.some((intermediate) => {
-        if (intermediate === child) {
-          return false;
-        }
-        if (intermediate.pathTokens.length <= pathTokens.length) {
-          return false;
-        }
-        if (intermediate.pathTokens.length >= child.pathTokens.length) {
-          return false;
-        }
-        return child.name.startsWith(`${intermediate.name}/`);
-      });
-      return !hasIntermediateRoute;
-    });
-  };
-  const rootEntries = entryStack.filter((entry) => {
-    const hasParent = entryStack.some((potential) => {
-      if (potential === entry) {
-        return false;
-      }
-      if (potential.pathTokens.length >= entry.pathTokens.length) {
-        return false;
-      }
-      return entry.name.startsWith(`${potential.name}/`);
-    });
-    return !hasParent;
-  });
-  return transformEntries(rootEntries);
-};
-
-// src/base-plugin/routes.ts
-var routes_default = async (pluginOptions) => {
-  const { appRoot, sourceFolder } = pluginOptions;
-  const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
-  const apiUseResolver = apiUseResolverFactory(pluginOptions);
-  const pageRouteResolver = pageRouteResolverFactory(pluginOptions);
-  const pageLayoutResolver = pageLayoutResolverFactory(pluginOptions);
-  const resolversFactory = (routeFiles2) => {
-    const resolvers = /* @__PURE__ */ new Map();
-    const entries = routeFiles2.flatMap((file) => {
-      const entry = createRouteEntry(file, pluginOptions);
-      return entry ? [entry] : [];
-    });
-    for (const entry of entries) {
-      if (entry.folder === defaults2.apiDir) {
-        if (isApiRoute(entry.file)) {
-          resolvers.set(entry.fileFullpath, apiRouteResolver(entry));
-        } else if (isApiUse(entry.file)) {
-          resolvers.set(entry.fileFullpath, apiUseResolver(entry));
-        }
-      } else if (entry.folder === defaults2.pagesDir) {
-        if (isPageRoute(entry.file)) {
-          resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
-        } else if (isPageLayout(entry.file)) {
-          resolvers.set(entry.fileFullpath, pageLayoutResolver(entry));
-        }
-      }
-    }
-    return resolvers;
-  };
-  const routeFiles = await scanRoutes({ appRoot, sourceFolder });
-  return {
-    resolvers: resolversFactory(routeFiles),
-    resolversFactory
-  };
-};
-export {
-  API_INDEX_BASENAME,
-  API_INDEX_PATTERN,
-  API_USE_BASENAME,
-  API_USE_PATTERN,
-  PAGE_INDEX_BASENAME,
-  PAGE_INDEX_PATTERN,
-  PAGE_LAYOUT_BASENAME,
-  PAGE_LAYOUT_PATTERN,
-  apiRouteResolverFactory,
-  apiUseResolverFactory,
-  createRouteEntry,
-  routes_default as default,
-  isApiRoute,
-  isApiUse,
-  isPageLayout,
-  isPageRoute,
-  isRouteFile,
-  nestedRoutesFactory,
-  pageLayoutResolverFactory,
-  pageRouteResolverFactory,
-  scanRoutes
-};
-//# sourceMappingURL=routes.js.map