@kosmojs/dev 0.0.0

package/pkg/index.js

@@ -0,0 +1,1004 @@
+// src/index.ts
+import { default as default2 } from "@kosmojs/api-generator";
+import { default as default3 } from "@kosmojs/fetch-generator";
+
+// src/alias-plugin/index.ts
+import { glob } from "tinyglobby";
+var alias_plugin_default = (appRoot, opt) => {
+  return {
+    name: "@kosmojs:aliasPlugin",
+    async config() {
+      const compilerOptions = await import(`${appRoot}/tsconfig.json`, {
+        with: { type: "json" }
+      }).then((e) => e.default.compilerOptions);
+      const aliasmap = [];
+      const pathEntries = Object.entries({ ...compilerOptions?.paths });
+      for (const [aliasPattern, pathPatterns] of pathEntries) {
+        const alias = aliasPattern.replace("/*", "");
+        const paths = pathPatterns.map((e) => e.replace("/*", "")).sort((a, b) => a.split(/\/+/).length - b.split(/\/+/).length);
+        if (paths.length === 1) {
+          aliasmap.push({
+            find: new RegExp(`^${alias}/`),
+            replacement: `${appRoot}/${paths[0]}/`
+          });
+        } else if (paths.length > 1) {
+          aliasmap.push({
+            find: new RegExp(`^${alias}/`),
+            replacement: "",
+            async customResolver(_src) {
+              const src = _src.replace(/(\$|\^|\+|\(|\)|\[|\])/g, "\\$1");
+              const patterns = paths.flatMap((path) => [
+                // Case 1: Extension is explicitly provided
+                // e.g. import styles from "@admin/{solid}/styles.module.css"
+                `${path}/${src}*`,
+                // Case 2: No extension provided
+                // Match any extension and return the first match
+                `${path}/${src}.*`,
+                // Case 3: Folder containing an index file of any extension
+                `${path}/${src}/index.*`
+              ]);
+              const [file] = await glob(patterns, {
+                cwd: appRoot,
+                onlyFiles: true,
+                absolute: true,
+                dot: true,
+                followSymbolicLinks: false,
+                braceExpansion: false,
+                globstar: false,
+                ignore: opt?.ignore || [
+                  "**/.git/**",
+                  "**/node_modules/**",
+                  "**/public/**",
+                  "**/var/**"
+                ]
+              });
+              return file;
+            }
+          });
+        }
+      }
+      return {
+        resolve: {
+          alias: aliasmap
+        }
+      };
+    }
+  };
+};
+
+// src/base-plugin/index.ts
+import { basename, join as join3, resolve as resolve5 } from "node:path";
+import { styleText as styleText2 } from "node:util";
+import { Worker } from "node:worker_threads";
+import apiGenerator from "@kosmojs/api-generator";
+import stubGenerator from "@kosmojs/dev/stub-generator";
+import fetchGenerator from "@kosmojs/fetch-generator";
+
+// src/base-plugin/api-handler.ts
+import { join, resolve } from "node:path";
+import { styleText } from "node:util";
+import { context } from "esbuild";
+import { defaults } from "@kosmojs/devlib";
+var api_handler_default = async (options) => {
+  const { appRoot, sourceFolder, baseurl, apiurl } = options;
+  const apiDir = join(sourceFolder, defaults.apiDir);
+  const outDir = join(options.outDir, defaults.apiDir);
+  const esbuildOptions = await import(resolve(appRoot, "esbuild.json"), { with: { type: "json" } }).then((e) => e.default);
+  let app;
+  let devMiddlewareFactory;
+  let teardownHandler;
+  const watcher = async () => {
+    const outfile = join(outDir, "dev.js");
+    const rebuildPlugin = {
+      name: "rebuild",
+      setup(build) {
+        build.onEnd(async () => {
+          if (app) {
+            await teardownHandler?.(app);
+          }
+          try {
+            const exports = await import([outfile, Date.now()].join("?"));
+            devMiddlewareFactory = exports.devMiddlewareFactory;
+            teardownHandler = exports.teardownHandler;
+            app = await exports.default();
+            console.debug(`${styleText("green", "\u279C")} Api handler ready`);
+          } catch (error) {
+            console.error(`${styleText("red", "\u2717")} Api handler error`);
+            console.error(error);
+          }
+        });
+      }
+    };
+    const ctx = await context({
+      ...esbuildOptions,
+      logLevel: "error",
+      bundle: true,
+      entryPoints: [join(apiDir, "app.ts")],
+      plugins: [rebuildPlugin],
+      outfile
+    });
+    return {
+      async start() {
+        await ctx.watch({
+          // waits this many milliseconds before rebuilding after a change is detected
+          delay: options.watcher.delay
+        });
+      },
+      async stop() {
+        await ctx.dispose();
+      }
+    };
+  };
+  const devMiddleware = async (req, res, viteHandler) => {
+    const next = () => {
+      return viteHandler();
+    };
+    if (devMiddlewareFactory) {
+      const handler = devMiddlewareFactory(app);
+      await handler(req, res, next);
+    } else {
+      !req?.url || !new RegExp(`^${join(baseurl, apiurl)}($|/)`).test(req.url) ? next() : await app?.callback()(req, res);
+    }
+  };
+  return {
+    watcher,
+    devMiddleware
+  };
+};
+
+// src/base-plugin/routes.ts
+import { dirname, join as join2, resolve as resolve4 } from "node:path";
+import crc3 from "crc/crc32";
+import picomatch from "picomatch";
+import { glob as glob2 } from "tinyglobby";
+import {
+  defaults as defaults2,
+  pathResolver as pathResolver2,
+  pathTokensFactory,
+  render,
+  renderToFile
+} from "@kosmojs/devlib";
+
+// src/base-plugin/ast.ts
+import { resolve as resolve2 } 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: resolve2(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 { resolve as resolve3 } from "node:path";
+import crc2 from "crc/crc32";
+import fsx from "fs-extra";
+import pkg from "@kosmojs/dev/package.json" with { type: "json" };
+import { pathResolver } from "@kosmojs/devlib";
+var cacheFactory = (route, {
+  appRoot,
+  sourceFolder,
+  extraContext
+}) => {
+  const cacheFile = pathResolver({
+    appRoot,
+    sourceFolder
+  }).resolve("apiLibDir", route.importPath, "cache.json");
+  const getCache = async (opt) => {
+    if (await fsx.exists(cacheFile)) {
+      try {
+        const cache = JSON.parse(await fsx.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 fsx.outputJson(cacheFile, cache, { spaces: 2 });
+    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(resolve3(appRoot, file)))) {
+        return;
+      }
+    }
+    return cache;
+  };
+  return {
+    getCache,
+    validateCache,
+    persistCache
+  };
+};
+var generateFileHash = async (file, extraContext) => {
+  let fileContent;
+  try {
+    fileContent = await fsx.readFile(file, "utf8");
+  } catch (_e) {
+    return 0;
+  }
+  return fileContent ? crc2(
+    JSON.stringify({
+      ...extraContext,
+      [pkg.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.ts
+var routes_default = async (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);
+  const routeFilePatterns = [
+    `${defaults2.apiDir}/**/index.ts`,
+    `${defaults2.pagesDir}/**/index.{ts,tsx,vue,svelte}`
+  ];
+  const resolveRouteFile = (file) => {
+    const [_sourceFolder, folder, ...rest] = resolve4(appRoot, file).replace(`${appRoot}/`, "").split("/");
+    if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
+      return;
+    }
+    return picomatch.isMatch(join2(folder, ...rest), routeFilePatterns) ? [folder, rest.join("/")] : void 0;
+  };
+  const resolversFactory = (routeFiles2) => {
+    const resolvers = /* @__PURE__ */ new Map();
+    const entries = routeFiles2.flatMap((_file) => {
+      const resolvedPaths = resolveRouteFile(_file);
+      if (!resolvedPaths) {
+        return [];
+      }
+      const [folder, file] = resolvedPaths;
+      const fileFullpath = join2(appRoot, sourceFolder, folder, file);
+      const pathTokens = pathTokensFactory(dirname(file));
+      const name = pathTokens.map((e) => e.orig).join("/");
+      const importPath = dirname(file);
+      const importName = [
+        importPath.split(/\[/)[0].replace(/^\W+|\W+$/g, "").replace(/\W+/g, "_"),
+        crc3(importPath)
+      ].join("_");
+      return [
+        {
+          name,
+          folder,
+          file,
+          fileFullpath,
+          pathTokens,
+          importPath,
+          importName
+        }
+      ];
+    });
+    for (const entry of entries.filter((e) => e.folder === defaults2.apiDir)) {
+      const {
+        name,
+        file,
+        folder,
+        fileFullpath,
+        pathTokens,
+        importPath,
+        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, importPath },
+          {
+            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 join2(sourceFolder, defaults2.apiDir, dirname(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",
+            importPath,
+            "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 route = {
+          name,
+          pathTokens,
+          params: cache.params,
+          numericParams: cache.numericParams,
+          optionalParams,
+          importName,
+          importPath,
+          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) => resolve4(appRoot, e)
+          )
+        };
+        return {
+          kind: "api",
+          route
+        };
+      };
+      resolvers.set(fileFullpath, { name, handler });
+    }
+    for (const entry of entries.filter((e) => e.folder === defaults2.pagesDir)) {
+      const {
+        //
+        name,
+        folder,
+        file,
+        fileFullpath,
+        pathTokens,
+        importPath,
+        importName
+      } = entry;
+      const handler = async () => {
+        const route = {
+          name,
+          pathTokens,
+          params: {
+            schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
+          },
+          folder,
+          file,
+          fileFullpath,
+          importPath,
+          importName
+        };
+        return {
+          kind: "page",
+          route
+        };
+      };
+      resolvers.set(fileFullpath, { name, handler });
+    }
+    return resolvers;
+  };
+  const routeFiles = await glob2(routeFilePatterns, {
+    cwd: resolve4(appRoot, sourceFolder),
+    absolute: true,
+    onlyFiles: true,
+    ignore: [
+      `${defaults2.apiDir}/index.ts`,
+      `${defaults2.pagesDir}/index.ts{x,}`
+    ]
+  });
+  return {
+    resolvers: resolversFactory(routeFiles),
+    resolversFactory,
+    resolveRouteFile
+  };
+};
+
+// src/base-plugin/spinner.ts
+import ora from "ora";
+var spinnerFactory = (startText) => {
+  const spinner = ora().start(startText);
+  let _text = startText;
+  return {
+    text(text) {
+      _text = text;
+      spinner.text = text;
+    },
+    append(text) {
+      spinner.text = `${_text} \u203A ${text}`;
+    },
+    succeed(text) {
+      if (text) {
+        this.append(text);
+      } else {
+        this.text(_text);
+      }
+      spinner.succeed();
+    },
+    failed(text) {
+      if (text) {
+        this.text([_text, text].join("\n"));
+      }
+      spinner.fail();
+    }
+  };
+};
+var withSpinner = (text, pipe, spinner) => pipe(spinner || spinnerFactory(text));
+
+// src/base-plugin/index.ts
+var base_plugin_default = (apiurl, pluginOptions) => {
+  const outDirSuffix = "client";
+  const store = {};
+  const createWorker = () => {
+    const {
+      generators = [],
+      formatters = [],
+      ...restOptions
+    } = store.resolvedOptions;
+    const generatorModules = generators.map(
+      (e) => [e.moduleImport, e.moduleConfig]
+    );
+    const formatterModules = pluginOptions?.formatters ? pluginOptions.formatters.map((e) => [e.moduleImport, e.moduleConfig]) : [];
+    const workerData = {
+      ...restOptions,
+      generatorModules,
+      formatterModules
+    };
+    return new Worker(resolve5(import.meta.dirname, "base-plugin/worker.js"), {
+      workerData,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1"
+      }
+    });
+  };
+  const workerHandler = (onReady, onExit) => {
+    const worker = createWorker();
+    const spinnerMap = /* @__PURE__ */ new Map();
+    worker.on("error", async (error) => {
+      console.error(error);
+    });
+    worker.on("exit", async () => {
+      await onExit?.();
+    });
+    worker.on(
+      "message",
+      async (msg) => {
+        if (msg?.spinner) {
+          const { id, startText, method, text } = msg.spinner;
+          withSpinner(
+            startText,
+            (spinner) => {
+              spinnerMap.set(id, spinner);
+              spinner[method](text || "");
+              if (method === "succeed" || method === "failed") {
+                spinnerMap.delete(id);
+              }
+            },
+            spinnerMap.get(id)
+          );
+        } else if (msg?.error) {
+          const { error } = msg;
+          if (error.stack) {
+            const [message, ...stack] = error.stack.split("\n");
+            console.error(styleText2("red", message));
+            console.error(stack.join("\n"));
+          } else if (error?.message) {
+            console.error(`${styleText2("red", error?.name)}: ${error.message}`);
+          } else {
+            console.error(error);
+          }
+        }
+      }
+    );
+    const readyHandler = async (msg) => {
+      if (msg === "ready") {
+        worker.off("message", readyHandler);
+        await onReady?.();
+      }
+    };
+    worker.on("message", readyHandler);
+    return async () => {
+      await worker.terminate();
+    };
+  };
+  return {
+    name: "@kosmojs:basePlugin",
+    config(config) {
+      if (!config.build?.outDir) {
+        throw new Error("Incomplete config, missing build.outDir");
+      }
+      return {
+        build: {
+          outDir: join3(config.build.outDir, outDirSuffix),
+          manifest: true
+        }
+      };
+    },
+    async configResolved(_config) {
+      store.config = _config;
+      const appRoot = resolve5(store.config.root, "..");
+      const sourceFolder = basename(store.config.root);
+      const outDir = resolve5(appRoot, resolve5(store.config.build.outDir, ".."));
+      const { stabilityThreshold = 1e3 } = typeof store.config.server.watch?.awaitWriteFinish === "object" ? store.config.server.watch.awaitWriteFinish : {};
+      const watcher = {
+        delay: stabilityThreshold,
+        ...store.config.server.watch ? { options: store.config.server.watch } : {}
+      };
+      {
+        const {
+          generators = [],
+          formatters = [],
+          refineTypeName = "TRefine"
+        } = { ...pluginOptions };
+        const _apiGenerator = generators.find((e) => e.kind === "api");
+        const _fetchGenerator = generators.find((e) => e.kind === "fetch");
+        const _ssrGenerator = generators.find((e) => e.kind === "ssr");
+        store.resolvedOptions = {
+          ...pluginOptions,
+          command: store.config.command,
+          watcher,
+          generators: [
+            // 1. stub generator should run first
+            stubGenerator(),
+            // 2. then api generator
+            _apiGenerator || apiGenerator(),
+            // 3. then fetch generator
+            _fetchGenerator || fetchGenerator(),
+            // 4. user generators in the order they were added
+            ...generators.filter((e) => {
+              return e.kind ? !["api", "fetch", "ssr"].includes(e.kind) : true;
+            }),
+            // 5. ssr generator should run last
+            ..._ssrGenerator ? [_ssrGenerator] : []
+          ],
+          formatters: formatters.map((e) => e.formatter),
+          refineTypeName,
+          baseurl: store.config.base,
+          apiurl,
+          appRoot,
+          sourceFolder,
+          outDir
+        };
+      }
+      if (store.config.command === "build") {
+        const { resolvers } = await routes_default(store.resolvedOptions);
+        const resolvedRoutes = [];
+        {
+          const spinner = spinnerFactory("Resolving Routes");
+          for (const { name, handler } of resolvers.values()) {
+            spinner.append(
+              `[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`
+            );
+            resolvedRoutes.push(await handler());
+          }
+          spinner.succeed();
+        }
+        {
+          const spinner = spinnerFactory("Running Generators");
+          for (const { name, factory } of store.resolvedOptions.generators) {
+            spinner.append(name);
+            const { watchHandler } = await factory(store.resolvedOptions);
+            await watchHandler(resolvedRoutes);
+          }
+          spinner.succeed();
+        }
+      }
+    },
+    async configureServer(server) {
+      if (store.config.command !== "serve") {
+        return;
+      }
+      const apiHandler = await api_handler_default(store.resolvedOptions);
+      const apiWatcher = await apiHandler.watcher();
+      const stopWorker = workerHandler(
+        async () => {
+          await apiWatcher.start();
+        },
+        async () => {
+          await apiWatcher.stop();
+        }
+      );
+      server.middlewares.use(apiHandler.devMiddleware);
+      server.httpServer?.on("close", stopWorker);
+    }
+  };
+};
+
+// src/define-plugin/index.ts
+import { parse as dotenv } from "dotenv";
+import fsx2 from "fs-extra";
+var define_plugin_default = (entries) => {
+  return {
+    name: "@kosmojs:definePlugin",
+    async config() {
+      const define = {};
+      for (const { keys, file, defineOn = "process.env", use } of entries) {
+        define[defineOn] = {};
+        const env = file && await fsx2.pathExists(file) ? dotenv(await fsx2.readFile(file, "utf8")) : process.env;
+        for (const [key, val] of Object.entries(env)) {
+          if (keys.includes(key)) {
+            define[`${defineOn}.${key}`] = JSON.stringify(val);
+          }
+          use?.(key, val);
+        }
+      }
+      return { define };
+    }
+  };
+};
+export {
+  alias_plugin_default as aliasPlugin,
+  default2 as apiGenerator,
+  base_plugin_default as default,
+  define_plugin_default as definePlugin,
+  default3 as fetchGenerator
+};
+//# sourceMappingURL=index.js.map