@kosmojs/dev 0.0.25 → 0.0.27

package/pkg/index.js

@@ -1,1781 +1,30 @@
-// src/alias-plugin/index.ts
-import { glob } from "tinyglobby";
-
-// src/paths.ts
-import { join } from "node:path";
-
-// src/defaults.ts
-var defaults = {
-  appPrefix: "~",
-  srcPrefix: "@",
-  libPrefix: "_",
-  coreDir: "core",
-  srcDir: "src",
-  libDir: "lib",
-  configDir: "config",
-  apiDir: "api",
-  pagesDir: "pages",
-  entryDir: "entry",
-  fetchDir: "fetch"
-};
-
-// src/paths.ts
-var createTsconfigPaths = (prefix) => {
-  return {
-    [`${defaults.appPrefix}/*`]: [`${prefix}/*`],
-    [`${defaults.srcPrefix}/*`]: [`${prefix}/${defaults.srcDir}/*`],
-    [`${defaults.libPrefix}/*`]: [
-      `${prefix}/${defaults.libDir}/${defaults.srcDir}/*`
-    ]
-  };
-};
-var pathResolver = ({
-  appRoot,
-  sourceFolder
-}) => {
-  const createPath = (...a) => {
-    return appRoot ? join(appRoot, ...a) : join(...a);
-  };
-  const createImport = {
-    coreApi(...a) {
-      return join(defaults.appPrefix, defaults.coreDir, defaults.apiDir, ...a);
-    },
-    src(...a) {
-      return join(defaults.srcPrefix, sourceFolder, ...a);
-    },
-    config(...a) {
-      return this.src(defaults.configDir, ...a);
-    },
-    api(...a) {
-      return this.src(defaults.apiDir, ...a);
-    },
-    pages(...a) {
-      return this.src(defaults.pagesDir, ...a);
-    },
-    lib(...a) {
-      return join(defaults.libPrefix, sourceFolder, ...a);
-    },
-    libApi(...a) {
-      return this.lib(defaults.apiDir, ...a);
-    },
-    libEntry(...a) {
-      return this.lib(defaults.entryDir, ...a);
-    }
-  };
-  return {
-    createPath: {
-      coreApi(...a) {
-        return createPath(defaults.coreDir, defaults.apiDir, ...a);
-      },
-      src(...a) {
-        return createPath(defaults.srcDir, sourceFolder, ...a);
-      },
-      api(...a) {
-        return this.src(defaults.apiDir, ...a);
-      },
-      pages(...a) {
-        return this.src(defaults.pagesDir, ...a);
-      },
-      config(...a) {
-        return this.src(defaults.configDir, ...a);
-      },
-      entry(...a) {
-        return this.src(defaults.entryDir, ...a);
-      },
-      lib(...a) {
-        return createPath(defaults.libDir, defaults.srcDir, sourceFolder, ...a);
-      },
-      libApi(...a) {
-        return this.lib(defaults.apiDir, ...a);
-      },
-      libEntry(...a) {
-        return this.lib(defaults.entryDir, ...a);
-      },
-      libPages(...a) {
-        return this.lib(defaults.pagesDir, ...a);
-      }
-    },
-    createImport,
-    createImportHelper: (key, ...a) => {
-      return createImport[key](...a.slice(0, -1));
-    }
-  };
-};
-
-// src/alias-plugin/index.ts
-var alias_plugin_default = (appRoot, opt) => {
-  return {
-    name: "@kosmojs:aliasPlugin",
-    async config() {
-      const paths = await import(`${appRoot}/tsconfig.json`, { with: { type: "json" } }).then((e) => {
-        return {
-          ...e.default.compilerOptions?.paths,
-          ...createTsconfigPaths(".")
-        };
-      });
-      const aliasmap = [];
-      const pathEntries = Object.entries(paths);
-      for (const [aliasPattern, pathPatterns] of pathEntries) {
-        const alias = aliasPattern.replace("/*", "");
-        const paths2 = pathPatterns.map((e) => e.replace("/*", "")).sort((a, b) => a.split(/\/+/).length - b.split(/\/+/).length);
-        if (paths2.length === 1) {
-          aliasmap.push({
-            find: new RegExp(`^${alias}/`),
-            replacement: `${appRoot}/${paths2[0]}/`
-          });
-        } else if (paths2.length > 1) {
-          aliasmap.push({
-            find: new RegExp(`^${alias}/`),
-            replacement: "",
-            async customResolver(_src) {
-              const src = _src.replace(/(\$|\^|\+|\(|\)|\[|\])/g, "\\$1");
-              const patterns = paths2.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 { writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename2, join as join5, resolve as resolve5 } from "node:path";
-import { styleText as styleText4 } from "node:util";
-import { Worker } from "node:worker_threads";
-import stubGenerator from "@kosmojs/dev/stub-generator";
-
-// src/routes-factory/resolve.ts
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
-import { styleText as styleText2 } from "node:util";
-import crc5 from "crc/crc32";
-import mimeTypes from "mime-types";
-import picomatch from "picomatch";
-import { glob as glob2 } from "tinyglobby";
-
-// src/ast.ts
-import { resolve } from "node:path";
-import { styleText } from "node:util";
-import crc from "crc/crc32";
-import { flattener } from "tfusion";
-import {
-  Project,
-  SyntaxKind
-} from "ts-morph";
-import {
-  HTTPMethods,
-  RequestValidationTargets
-} 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(route, defaultExport) : [];
-  return {
-    typeDeclarations,
-    paramsRefinements,
-    methods: methods.map((e) => e.method),
-    validationDefinitions: methods.flatMap((e) => e.validationDefinitions),
-    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 [
-    _routeName,
-    // first generic - the route name
-    paramsGeneric
-    // second generic - params refinements
-  ] = extractGenerics(callExpression);
-  if (!paramsGeneric?.isKind(SyntaxKind.TupleType)) {
-    return;
-  }
-  return paramsGeneric.getElements().map((node, index) => {
-    return {
-      index,
-      text: node.getText()
-    };
-  });
-};
-var extractRouteMethods = (route, callExpression) => {
-  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 = [];
-  for (const [callExpression2, method] of callExpressions) {
-    const [vDefs, vOpts] = extractGenerics(callExpression2);
-    methods.push({
-      method,
-      validationDefinitions: extractValidationDefinitions(
-        route,
-        method,
-        vDefs,
-        vOpts
-      )
-    });
-  }
-  return methods;
-};
-var parseRuntimeValidation = (typeNode) => {
-  if (typeNode.isKind(SyntaxKind.LiteralType)) {
-    const literal = typeNode.getFirstChild();
-    if (literal?.isKind(SyntaxKind.TrueKeyword)) {
-      return true;
-    } else if (literal?.isKind(SyntaxKind.FalseKeyword)) {
-      return false;
-    }
-  }
-  return void 0;
-};
-var extractResponseVariant = (typeNode) => {
-  if (!typeNode.isKind(SyntaxKind.TupleType)) {
-    return;
-  }
-  let status = 200;
-  let contentType;
-  let body;
-  const [statusNode, contentTypeNode, bodyNode] = typeNode.getElements();
-  if (statusNode?.isKind(SyntaxKind.LiteralType)) {
-    const literal = statusNode.getFirstChildByKind(SyntaxKind.NumericLiteral);
-    if (literal) {
-      status = Number(literal.getText());
-    }
-  }
-  if (contentTypeNode) {
-    contentType = extractStringLiteral(contentTypeNode);
-  }
-  if (bodyNode) {
-    body = bodyNode.getText();
-    if (["object"].includes(body)) {
-      body = "{}";
-    }
-  }
-  return { status, contentType, body };
-};
-var parseValidationOptions = (typeNode) => {
-  const opts = {};
-  if (!typeNode?.isKind(SyntaxKind.TypeLiteral)) {
-    return opts;
-  }
-  for (const prop of typeNode.getMembers()) {
-    if (!prop.isKind(SyntaxKind.PropertySignature)) {
-      continue;
-    }
-    const target = prop.getName();
-    const typeNode2 = prop.getTypeNodeOrThrow();
-    if (!typeNode2.isKind(SyntaxKind.TypeLiteral)) {
-      continue;
-    }
-    let contentType;
-    let runtimeValidation;
-    const customErrors = {};
-    for (const member of typeNode2.getMembers()) {
-      if (!member.isKind(SyntaxKind.PropertySignature)) {
-        continue;
-      }
-      const nameNode = member.getNameNode();
-      const valueNode = member.getTypeNodeOrThrow();
-      const name = nameNode.isKind(SyntaxKind.StringLiteral) ? nameNode.getLiteralText() : nameNode.getText();
-      if (name === "contentType") {
-        contentType = extractStringLiteral(valueNode);
-      } else if (name === "runtimeValidation") {
-        runtimeValidation = parseRuntimeValidation(valueNode);
-      } else if (name.startsWith("error")) {
-        const literal = extractStringLiteral(valueNode);
-        if (literal) {
-          customErrors[name] = literal;
-        }
-      }
-    }
-    opts[target] = {
-      contentType,
-      runtimeValidation,
-      customErrors
-    };
-  }
-  return opts;
-};
-var extractStringLiteral = (typeNode) => {
-  const literal = typeNode.isKind(SyntaxKind.LiteralType) ? typeNode.getFirstChildByKind(SyntaxKind.StringLiteral) : void 0;
-  return literal ? literal.getLiteralText() : void 0;
-};
-var extractValidationDefinitions = (route, method, defsNode, optsNode) => {
-  const definitions = [];
-  if (!defsNode?.isKind(SyntaxKind.TypeLiteral)) {
-    return definitions;
-  }
-  const optsMap = parseValidationOptions(optsNode);
-  const createId = (target, hash) => {
-    return [
-      target.replace(/^./, (c) => c.toUpperCase()),
-      "T",
-      method,
-      crc(route.id + hash)
-    ].join("");
-  };
-  for (const prop of defsNode.getMembers()) {
-    if (!prop.isKind(SyntaxKind.PropertySignature)) {
-      continue;
-    }
-    const target = prop.getName();
-    const typeNode = prop.getTypeNodeOrThrow();
-    if (target === "response") {
-      const variants = typeNode.isKind(SyntaxKind.UnionType) ? typeNode.getChildrenOfKind(SyntaxKind.TupleType) : [typeNode];
-      definitions.push({
-        ...optsMap[target],
-        method,
-        target,
-        variants: variants.flatMap((e, i) => {
-          const { status, contentType, body } = extractResponseVariant(e) || {};
-          if (!status) {
-            return [];
-          }
-          if (contentType && typeof contentType !== "string") {
-            console.warn(
-              styleText(
-                ["bold", "red"],
-                `\u2717 The second element of a response variant should specify the Response Content Type`
-              )
-            );
-            console.warn(
-              styleText(["blue"], `  Example: [200, "json", Schema]`)
-            );
-            console.warn(
-              `  Route: ${route.name}; Method: ${method}; Response Variant: #${i}`
-            );
-            console.warn();
-          }
-          return [
-            {
-              id: createId(target, JSON.stringify([status, contentType, body])),
-              status,
-              contentType,
-              body
-            }
-          ];
-        })
-      });
-    } else if (Object.keys(RequestValidationTargets).includes(target)) {
-      definitions.push({
-        ...optsMap[target],
-        method,
-        target,
-        schema: {
-          id: createId(target),
-          text: typeNode.getText()
-        }
-      });
-    }
-  }
-  return definitions;
-};
-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();
-};
-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/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" };
-
-// src/fs.ts
-import { access, constants } from "node:fs/promises";
-var pathExists = async (path) => {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/cache.ts
-var cacheFactory = (route, {
-  appRoot,
-  sourceFolder,
-  extraContext
-}) => {
-  const cacheFile = pathResolver({
-    appRoot,
-    sourceFolder
-  }).createPath.libApi(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/render.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join2 } from "node:path";
-import crc3 from "crc/crc32";
-import handlebars from "handlebars";
-var render = (template, context2, options) => {
-  const { noEscape = true, renderer = handlebars } = { ...options };
-  return renderer.compile(template, { noEscape })(context2);
-};
-var renderToFile = async (file, template, context2, options) => {
-  const content = render(template, context2, options);
-  if (await pathExists(file)) {
-    const { overwrite = true } = { ...options };
-    if (overwrite === false) {
-      return;
-    }
-    const fileContent = await readFile2(file, "utf8");
-    if (typeof overwrite === "function" && !overwrite(fileContent)) {
-      return;
-    }
-    if (crc3(content) === crc3(fileContent)) {
-      return;
-    }
-  }
-  await mkdir2(dirname2(file), { recursive: true });
-  await writeFile2(file, content, "utf8");
-};
-var renderFactory = (options) => {
-  const renderer = handlebars.create();
-  renderer.registerPartial({ ...options?.partials });
-  renderer.registerHelper({ ...options?.helpers });
-  return {
-    render(template, context2, selfOoptions) {
-      return render(template, context2, {
-        renderer,
-        ...options,
-        ...selfOoptions
-      });
-    },
-    async renderToFile(file, template, context2, selfOoptions) {
-      return renderToFile(
-        options?.outdir ? join2(options.outdir, file) : file,
-        template,
-        context2,
-        { renderer, ...options, ...selfOoptions }
-      );
-    }
-  };
-};
-var renderHelpers = {
-  createParamsLiteral: (params) => {
-    return params.schema.map((p) => {
-      return p.kind === "splat" ? `${p.const}?: Array<string | number>` : p.kind === "optional" ? `${p.const}?: string | number` : `${p.const}: string | number`;
-    }).join(", ");
-  }
-};
-
-// src/routes-factory/base.ts
-import crc4 from "crc/crc32";
-import { parse } from "path-to-regexp";
-var pathTokensFactory = (path, {
-  transformStaticValue = normalizeStaticValue
-} = {}) => {
-  const extractParts = (tokens2, createConst, insideGroup = false) => {
-    const parts = [];
-    for (const token of tokens2) {
-      switch (token.type) {
-        case "text":
-          if (token.value !== "/") {
-            parts.push({
-              type: "static",
-              value: transformStaticValue(token.value)
-            });
-          }
-          break;
-        case "param":
-          parts.push({
-            type: "param",
-            kind: insideGroup ? "optional" : "required",
-            name: token.name,
-            const: createConst(token.name)
-          });
-          break;
-        case "wildcard":
-          parts.push({
-            type: "param",
-            kind: "splat",
-            name: token.name,
-            const: createConst(token.name)
-          });
-          break;
-        case "group":
-          parts.push(...extractParts(token.tokens, createConst, true));
-          break;
-      }
-    }
-    return parts;
-  };
-  const patternTransforms = [
-    // Transform required params: [id] => :id
-    // Only pure \w param names,
-    // [some-id] used as is, not treated as param,
-    // use [some_id] instead.
-    (s) => s.replace(/\[(\w+)\]/g, ":$1"),
-    // Transform optional params: {id} => {:id}
-    // Only pure \w param names,
-    // anything else treated as a path-to-regexp pattern and used as is.
-    // {some-id} treated as an optional static segment.
-    // use {some_id} for simple param syntax
-    // or {:some-id} pattern where :some is the param name and -id is a static segment.
-    (s) => s.replace(/\{(\w+)\}/g, "{:$1}"),
-    // Transform splat params: {...param} => {*param}
-    (s) => s.replace(/\{\.\.\./g, "{*"),
-    // Insert leading slash inside optional/splat groups.
-    // {:name} => {/:name}
-    // {*name} => {/*name}
-    (s) => {
-      return s.startsWith("{") ? s.replace(/^\{/, "{/") : s;
-    }
-  ];
-  const detectBareParams = (s) => {
-    let depth = 0;
-    for (const [i, ch] of [...s].entries()) {
-      if (ch === "{") {
-        depth += 1;
-      } else if (ch === "}") {
-        depth -= 1;
-      } else if (ch === ":" && depth === 0) {
-        const match = s.slice(i + 1).match(/^\w+/);
-        return match?.[0] || ":";
-      }
-    }
-    return;
-  };
-  const tokens = path.replace(/^index\/?/, "").split("/").flatMap((orig) => {
-    if (!orig.length) {
-      return [];
-    }
-    const bareParam = detectBareParams(orig);
-    if (bareParam === ":") {
-      throw new Error(
-        `${path} contains colons outside braces, use : only within {}`
-      );
-    } else if (bareParam) {
-      throw new Error(
-        `${path} contains bare params, use [${bareParam}] instead of :${bareParam}`
-      );
-    }
-    const pattern = patternTransforms.reduce((src, fn) => fn(src), orig);
-    const { tokens: tokens2 } = parse(pattern);
-    const parts = extractParts(tokens2, (val) => {
-      return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc4(orig)].join("_") : val;
-    });
-    const isStatic = parts.length === 1 ? parts[0].type === "static" : false;
-    const isParam = parts.length === 1 ? parts[0].type === "param" : false;
-    const kind = isStatic ? "static" : isParam ? "param" : "mixed";
-    return [
-      {
-        kind,
-        orig,
-        pattern,
-        parts
-      }
-    ];
-  });
-  return [
-    tokens,
-    tokens.map(({ pattern }, i) => {
-      const next = tokens[i + 1];
-      if (!next || next.pattern.includes("/")) {
-        return pattern;
-      }
-      const slashRequired = tokens.slice(i + 1).some((e) => {
-        return e.parts.some((e2) => {
-          return e2.type === "static" || e2.kind === "required";
-        });
-      });
-      return slashRequired ? `${pattern}/` : pattern;
-    }).join("")
-  ];
-};
-var normalizeStaticValue = (value) => {
-  return value.replace(/\+/g, "\\\\+");
-};
-var sortRoutes = (a, b) => {
-  const aSpecificity = routeSpecificity(a.pathTokens);
-  const bSpecificity = routeSpecificity(b.pathTokens);
-  if (aSpecificity !== bSpecificity) {
-    return bSpecificity - aSpecificity;
-  }
-  if (a.pathTokens.length !== b.pathTokens.length) {
-    return a.pathTokens.length - b.pathTokens.length;
-  }
-  return a.name.localeCompare(b.name);
-};
-var paramWeight = (part) => {
-  return {
-    required: 2,
-    optional: 1,
-    splat: 0
-  }[part.kind];
-};
-var mixedSegmentWeight = (parts) => {
-  const hasSplat = parts.some((p) => {
-    return p.type === "param" ? p.kind === "splat" : false;
-  });
-  return hasSplat ? 0.5 : 3;
-};
-var segmentWeight = (token) => {
-  return {
-    static: 4,
-    mixed: mixedSegmentWeight(token.parts),
-    param: paramWeight(token.parts[0])
-  }[token.kind];
-};
-var routeSpecificity = (pathTokens) => {
-  return pathTokens.reduce((sum, token) => sum + segmentWeight(token), 0);
-};
-
-// src/routes-factory/templates/resolved-types.hbs
-var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
-
-// src/routes-factory/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 refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n';
-
-// src/routes-factory/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
-}) => {
-  const { createPath } = pathResolver({ appRoot, sourceFolder });
-  return glob2(ROUTE_FILE_PATTERNS, {
-    cwd: createPath.src(),
-    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}/${defaults.srcDir}/`, "").split("/");
-  if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
-    return false;
-  }
-  return picomatch.isMatch(join3(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : false;
-};
-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 = (fileFullpath, {
-  appRoot,
-  sourceFolder
-}) => {
-  const resolvedPaths = isRouteFile(fileFullpath, { appRoot, sourceFolder });
-  if (!resolvedPaths) {
-    return;
-  }
-  const [folder, file] = resolvedPaths;
-  const id = `${file.replace(/\W+/g, "_")}_${crc5(file)}`;
-  const name = dirname3(file);
-  try {
-    const [pathTokens, pathPattern] = pathTokensFactory(dirname3(file));
-    return { id, name, folder, file, fileFullpath, pathTokens, pathPattern };
-  } catch (error) {
-    console.error(
-      `\u2757${styleText2("red", "ERROR")}: Failed parsing path for "${styleText2("cyan", file)}"`
-    );
-    console.error(error);
-    return;
-  }
-};
-var pageLayoutResolverFactory = () => {
-  return (entry) => {
-    const { name } = entry;
-    const handler = async () => {
-      return {
-        kind: "pageLayout",
-        entry
-      };
-    };
-    return { name, handler };
-  };
-};
-var pageRouteResolverFactory = () => {
-  return (entry) => {
-    const { id, name, folder, file, fileFullpath, pathTokens, pathPattern } = entry;
-    const handler = async () => {
-      const entry2 = {
-        id,
-        name,
-        pathTokens,
-        pathPattern,
-        params: {
-          schema: pathTokens.flatMap((e) => {
-            return e.parts.filter((p) => p.type === "param");
-          })
-        },
-        folder,
-        file,
-        fileFullpath
-      };
-      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 = [],
-    refineTypeName
-  } = pluginOptions;
-  const resolveTypes = generators.some((e) => e.options?.resolveTypes);
-  const {
-    //
-    literalTypesResolver,
-    getSourceFile,
-    refreshSourceFile
-  } = typeResolverFactory(pluginOptions);
-  return ({
-    id,
-    name,
-    file,
-    folder,
-    fileFullpath,
-    pathTokens,
-    pathPattern
-  }) => {
-    const handler = async (updatedFile) => {
-      const paramsSchema = pathTokens.flatMap(
-        (e) => {
-          return e.parts.flatMap((p) => {
-            return p.type === "param" ? [p] : [];
-          });
-        }
-      );
-      const optionalParams = paramsSchema.length ? paramsSchema.filter((e) => e.kind === "required").length === 0 : true;
-      const { getCache, persistCache } = cacheFactory(
-        { id, file, fileFullpath },
-        {
-          appRoot,
-          sourceFolder,
-          extraContext: { resolveTypes }
-        }
-      );
-      let cache = await getCache({ validate: true });
-      if (!cache) {
-        if (updatedFile === fileFullpath) {
-          await refreshSourceFile(fileFullpath);
-        }
-        const {
-          typeDeclarations,
-          paramsRefinements,
-          methods,
-          validationDefinitions: validationDefinitions2,
-          referencedFiles = []
-        } = await resolveRouteSignature(
-          { id, name, fileFullpath, optionalParams },
-          {
-            withReferencedFiles: true,
-            sourceFile: getSourceFile(fileFullpath),
-            relpathResolver(path) {
-              return join3(sourceFolder, defaults.apiDir, dirname3(file), path);
-            }
-          }
-        );
-        const validationTypes = validationDefinitions2.flatMap((def) => {
-          return def.target === "response" ? def.variants.flatMap(({ id: id2, body }) => {
-            return body ? [{ id: id2, text: body }] : [];
-          }) : [def.schema];
-        });
-        const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
-          if (text === "number") {
-            const param = paramsSchema.at(index);
-            return param ? [param.name] : [];
-          }
-          return [];
-        }) : [];
-        const typesFile = pathResolver({
-          appRoot,
-          sourceFolder
-        }).createPath.libApi(dirname3(file), "types.ts");
-        const params = {
-          id: ["ParamsT", crc5(name)].join(""),
-          schema: paramsSchema,
-          resolvedType: void 0
-        };
-        const typesFileContent = render(types_default, {
-          params,
-          paramsSchema: paramsSchema.map((param, index) => {
-            return {
-              ...param,
-              isRequired: param.kind === "required",
-              isSplat: param.kind === "splat",
-              refinement: paramsRefinements?.at(index)
-            };
-          }),
-          typeDeclarations,
-          validationTypes
-        });
-        const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
-          stripComments: true,
-          overrides: { [refineTypeName]: refineTypeName },
-          withProperties: [
-            params.id,
-            ...validationTypes.flatMap(({ id: id2 }) => id2)
-          ]
-        }) : 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,
-          referencedFiles,
-          validationDefinitions: validationDefinitions2.map((def) => {
-            return {
-              ...def,
-              ...def.target === "response" ? {
-                variants: def.variants.map((variant) => {
-                  return {
-                    ...variant,
-                    resolvedType: resolvedTypes?.find(
-                      (e) => e.name === variant.id
-                    )
-                  };
-                })
-              } : {
-                schema: {
-                  ...def.schema,
-                  resolvedType: resolvedTypes?.find(
-                    (e) => e.name === def.schema.id
-                  )
-                }
-              }
-            };
-          })
-        });
-      }
-      const validationDefinitions = cache.validationDefinitions.flatMap(
-        (def) => {
-          let augmentedDef = def;
-          if (def.target === "response") {
-            augmentedDef = {
-              ...def,
-              variants: def.variants.flatMap((variant, i) => {
-                if (typeof variant.contentType !== "string") {
-                  return [variant];
-                }
-                if (variant.contentType.includes("/")) {
-                  return [variant];
-                }
-                const contentType = mimeTypes.lookup(variant.contentType);
-                if (contentType === false) {
-                  console.warn(
-                    styleText2(
-                      ["bold", "red"],
-                      "\u2717 Failed resolving Response Content Type"
-                    )
-                  );
-                  console.warn(
-                    `  Invalid value provided for mime-types lookup - ${variant.contentType}`
-                  );
-                  console.warn(
-                    styleText2(
-                      ["cyan"],
-                      `  Response variant #${i} excluded from route schemas`
-                    )
-                  );
-                  console.warn(`  Route: ${name}; Method: ${def.method}`);
-                  console.warn();
-                  return [];
-                }
-                return [{ ...variant, contentType }];
-              })
-            };
-          } else if (def.contentType && !def.contentType.includes("/")) {
-            const contentType = mimeTypes.lookup(def.contentType);
-            if (contentType === false) {
-              console.warn(
-                styleText2(
-                  ["bold", "red"],
-                  "\u2717 Failed resolving Response Content Type"
-                )
-              );
-              console.warn(
-                `  Invalid value provided for mime-types lookup - ${def.contentType}`
-              );
-              console.warn(`  Route: ${name}; Method: ${def.method}`);
-              console.warn();
-            } else {
-              augmentedDef = { ...def, contentType };
-            }
-          }
-          return augmentedDef ? [augmentedDef] : [];
-        }
-      );
-      const entry = {
-        id,
-        name,
-        pathTokens,
-        pathPattern,
-        params: cache.params,
-        numericParams: cache.numericParams,
-        optionalParams,
-        folder,
-        file,
-        fileFullpath,
-        methods: cache.methods,
-        typeDeclarations: cache.typeDeclarations,
-        validationDefinitions,
-        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
-      };
-    };
-    return { name, handler };
-  };
-};
-
-// src/routes-factory/nesting.ts
-import { basename } from "node:path";
-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/routes-factory/index.ts
-var routesFactory = 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 === defaults.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 === defaults.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
-  };
-};
-
-// src/base-plugin/api-handler.ts
-import { join as join4, resolve as resolve4 } from "node:path";
-import { styleText as styleText3 } from "node:util";
-import { context } from "esbuild";
-var api_handler_default = async (options) => {
-  const { appRoot, sourceFolder, baseurl, apiurl } = options;
-  const { createPath } = pathResolver({ appRoot, sourceFolder });
-  const outDir = join4(options.outDir, defaults.apiDir);
-  const esbuildOptions = await import(resolve4(appRoot, "esbuild.json"), { with: { type: "json" } }).then((e) => e.default);
-  let devSetup;
-  const watcher = async () => {
-    const rebuildPlugin = {
-      name: "rebuild",
-      setup(build) {
-        build.onEnd(async () => {
-          if (devSetup) {
-            await devSetup.teardownHandler?.();
-          }
-          try {
-            await import(`${outDir}/dev.js?${Date.now()}`).then((e) => {
-              devSetup = e.default;
-            });
-            console.debug(`${styleText3("green", "\u279C")} Api handler ready`);
-          } catch (error) {
-            console.error(`${styleText3("red", "\u2717")} Api handler error`);
-            console.error(error);
-          }
-        });
-      }
-    };
-    const ctx = await context({
-      ...esbuildOptions,
-      define: {
-        ...esbuildOptions.define,
-        PRODUCTION_BUILD: "false"
-      },
-      logLevel: "error",
-      bundle: true,
-      entryPoints: [createPath.api("dev.ts")],
-      plugins: [rebuildPlugin],
-      outdir: outDir
-    });
-    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, next) => {
-    const {
-      requestMatcher = () => {
-        return new RegExp(`^${join4(baseurl, apiurl)}($|/)`).test(
-          req.url
-        );
-      },
-      requestHandler
-    } = { ...devSetup };
-    if (!requestMatcher(req)) {
-      return next();
-    }
-    const handler = requestHandler?.();
-    return handler ? handler(req, res) : next();
-  };
-  return {
-    watcher,
-    devMiddleware
-  };
-};
-
-// src/base-plugin/spinner.ts
-import { Spinner } from "@topcli/spinner";
-var spinnerFactory = (startText) => {
-  const spinner = new Spinner().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.failed();
-    }
-  };
-};
-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 = [], ...restOptions } = store.resolvedOptions;
-    const generatorModules = generators.map(
-      (e) => [e.moduleImport, e.moduleConfig]
-    );
-    const workerData = {
-      ...restOptions,
-      generatorModules
-    };
-    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(styleText4("red", message));
-            console.error(stack.join("\n"));
-          } else if (error?.message) {
-            console.error(`${styleText4("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: join5(config.build.outDir, outDirSuffix),
-          manifest: true
-        }
-      };
-    },
-    async configResolved(_config) {
-      store.config = _config;
-      const appRoot = resolve5(store.config.root, "../..");
-      const sourceFolder = basename2(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 = [], refineTypeName = "TRefine" } = {
-          ...pluginOptions
-        };
-        const apiGenerator = generators.find((e) => e.slot === "api");
-        const fetchGenerator = generators.find((e) => e.slot === "fetch");
-        const ssrGenerator = generators.find((e) => e.slot === "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, only if api generator also enabled
-            ...fetchGenerator && apiGenerator ? [fetchGenerator] : [],
-            // 4. user generators in the order they were added
-            ...generators.filter((e) => {
-              return e.slot ? !["api", "fetch", "ssr"].includes(e.slot) : true;
-            }),
-            // 5. ssr generator should run last
-            ...ssrGenerator ? [ssrGenerator] : []
-          ],
-          refineTypeName,
-          baseurl: store.config.base,
-          apiurl,
-          appRoot,
-          sourceFolder,
-          outDir
-        };
-      }
-      const packageJsonFile = resolve5(appRoot, "package.json");
-      const packageJson = await import(packageJsonFile, {
-        with: { type: "json" }
-      }).then((e) => e.default);
-      const newDependencies = [];
-      for (const generator of store.resolvedOptions.generators) {
-        for (const key of ["dependencies", "devDependencies"]) {
-          for (const [pkg, ver] of Object.entries(generator[key] || {})) {
-            if (!packageJson[key]?.[pkg]) {
-              newDependencies.push([key, pkg, ver]);
-            }
-          }
-        }
-      }
-      if (newDependencies.length) {
-        console.warn();
-        console.warn(
-          [
-            "\u{1F4A1} ",
-            styleText4(["bold", "italic", "red"], "New dependencies added: "),
-            styleText4("dim", newDependencies.map(([, pkg]) => pkg).join(", "))
-          ].join("")
-        );
-        console.warn(
-          "\u{1F4E6}",
-          [
-            styleText4(
-              ["bold", "blueBright"],
-              store.config.command === "build" ? "Install them and run a new build: " : "Install them and restart dev server: "
-            ),
-            styleText4(
-              "dim",
-              ["npm", "pnpm", "yarn"].map((e) => `\`${e} install\``).join(" / ")
-            )
-          ].join("")
-        );
-        console.warn();
-        for (const [key, pkg, ver] of newDependencies) {
-          packageJson[key] = { ...packageJson[key], [pkg]: ver };
-        }
-        await writeFile3(
-          packageJsonFile,
-          JSON.stringify(packageJson, null, 2),
-          "utf8"
-        );
-      }
-      if (store.config.command === "build") {
-        const { resolvers } = await routesFactory(store.resolvedOptions);
-        const resolvedEntries = [];
-        {
-          const spinner = spinnerFactory("Resolving Routes");
-          for (const { name, handler } of resolvers.values()) {
-            spinner.append(
-              `[ ${resolvedEntries.length + 1} of ${resolvers.size} ] ${name}`
-            );
-            resolvedEntries.push(await handler());
-          }
-          spinner.succeed();
-        }
-        {
-          const spinner = spinnerFactory("Running Generators");
-          for (const { name, factory } of store.resolvedOptions.generators) {
-            spinner.append(name);
-            const { build } = await factory(store.resolvedOptions);
-            await build(resolvedEntries);
-          }
-          spinner.succeed();
-        }
-      }
-    },
-    async configureServer(server) {
-      if (store.config.command !== "serve") {
-        return;
-      }
-      if (!store.resolvedOptions.generators.find((e) => e.slot === "api")) {
-        const stopWorker2 = workerHandler(() => stopWorker2());
-        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 { readFile as readFile3 } from "node:fs/promises";
-import { parseEnv } from "node:util";
-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 fileExists = file ? await pathExists(file) : false;
-        const env = fileExists ? parseEnv(await readFile3(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 };
-    }
-  };
-};
-
-// src/typebox.ts
-var typeboxLiteralText = (text, options) => {
-  return [
-    // Escape backticks for safe use in template literals
-    [/(?<!\\)`/g, "\\`"],
-    // Escape $ for safe use in template literals
-    [/(?<!\\)\$\{/g, "\\${"],
-    /**
-     * TypeBox's built-in `Options` type is not configurable.
-     * To allow a custom type name, exposing `refineTypeName` option,
-     * defaulted to TRefine, then renaming it to `Options`.
-     * */
-    [new RegExp(`\\b${options.refineTypeName}\\s*<`, "g"), "Options<"]
-  ].reduce((text2, [a, b]) => text2.replace(a, b), text);
+// src/index.ts
+import { default as default2 } from "@kosmojs/fetch-generator";
+import { default as default3 } from "@kosmojs/hono-generator";
+import { default as default4 } from "@kosmojs/koa-generator";
+import { default as default5 } from "@kosmojs/mdx-generator";
+import { default as default6 } from "@kosmojs/openapi-generator";
+import { default as default7 } from "@kosmojs/react-generator";
+import { default as default8 } from "@kosmojs/solid-generator";
+import { default as default9 } from "@kosmojs/ssg-generator";
+import { default as default10 } from "@kosmojs/ssr-generator";
+import { default as default11 } from "@kosmojs/typebox-generator";
+import { default as default12 } from "@kosmojs/vue-generator";
+var defineConfig = (config) => {
+  return config;
 };
 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,
-  alias_plugin_default as aliasPlugin,
-  apiRouteResolverFactory,
-  apiUseResolverFactory,
-  createRouteEntry,
-  createTsconfigPaths,
-  base_plugin_default as default,
-  defaults,
-  define_plugin_default as definePlugin,
-  isApiRoute,
-  isApiUse,
-  isPageLayout,
-  isPageRoute,
-  isRouteFile,
-  nestedRoutesFactory,
-  normalizeStaticValue,
-  pageLayoutResolverFactory,
-  pageRouteResolverFactory,
-  pathResolver,
-  pathTokensFactory,
-  render,
-  renderFactory,
-  renderHelpers,
-  renderToFile,
-  routesFactory,
-  scanRoutes,
-  sortRoutes,
-  typeboxLiteralText
+  defineConfig,
+  default2 as fetchGenerator,
+  default3 as honoGenerator,
+  default4 as koaGenerator,
+  default5 as mdxGenerator,
+  default6 as openapiGenerator,
+  default7 as reactGenerator,
+  default8 as solidGenerator,
+  default9 as ssgGenerator,
+  default10 as ssrGenerator,
+  default11 as typeboxGenerator,
+  default12 as vueGenerator
 };
 //# sourceMappingURL=index.js.map