@kosmojs/dev 0.0.25 → 0.0.27

package/pkg/base-plugin/worker.js

@@ -1,1321 +0,0 @@
-// src/base-plugin/worker.ts
-import { parentPort, workerData } from "node:worker_threads";
-import chokidar from "chokidar";
-import crc6 from "crc/crc32";
-
-// 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 pathResolver = ({
-  appRoot: appRoot2,
-  sourceFolder: sourceFolder2
-}) => {
-  const createPath2 = (...a) => {
-    return appRoot2 ? join(appRoot2, ...a) : join(...a);
-  };
-  const createImport = {
-    coreApi(...a) {
-      return join(defaults.appPrefix, defaults.coreDir, defaults.apiDir, ...a);
-    },
-    src(...a) {
-      return join(defaults.srcPrefix, sourceFolder2, ...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, sourceFolder2, ...a);
-    },
-    libApi(...a) {
-      return this.lib(defaults.apiDir, ...a);
-    },
-    libEntry(...a) {
-      return this.lib(defaults.entryDir, ...a);
-    }
-  };
-  return {
-    createPath: {
-      coreApi(...a) {
-        return createPath2(defaults.coreDir, defaults.apiDir, ...a);
-      },
-      src(...a) {
-        return createPath2(defaults.srcDir, sourceFolder2, ...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 createPath2(defaults.libDir, defaults.srcDir, sourceFolder2, ...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/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 } 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: appRoot2 }) => {
-  const project = createProject({
-    tsConfigFilePath: resolve(appRoot2, "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: appRoot2,
-  sourceFolder: sourceFolder2,
-  extraContext
-}) => {
-  const cacheFile = pathResolver({
-    appRoot: appRoot2,
-    sourceFolder: sourceFolder2
-  }).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(`${appRoot2}/`, "")
-      ] = 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(appRoot2, 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, context, options) => {
-  const { noEscape = true, renderer = handlebars } = { ...options };
-  return renderer.compile(template, { noEscape })(context);
-};
-var renderToFile = async (file, template, context, options) => {
-  const content = render(template, context, 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");
-};
-
-// 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, "\\\\+");
-};
-
-// 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: appRoot2,
-  sourceFolder: sourceFolder2
-}) => {
-  const { createPath: createPath2 } = pathResolver({ appRoot: appRoot2, sourceFolder: sourceFolder2 });
-  return glob(ROUTE_FILE_PATTERNS, {
-    cwd: createPath2.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: appRoot2,
-  sourceFolder: sourceFolder2
-}) => {
-  const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/${defaults.srcDir}/`, "").split("/");
-  if (!folder || _sourceFolder !== sourceFolder2 || 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: appRoot2,
-  sourceFolder: sourceFolder2
-}) => {
-  const resolvedPaths = isRouteFile(fileFullpath, { appRoot: appRoot2, sourceFolder: sourceFolder2 });
-  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: appRoot2,
-    sourceFolder: sourceFolder2,
-    generators: generators2 = [],
-    refineTypeName
-  } = pluginOptions;
-  const resolveTypes = generators2.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: appRoot2,
-          sourceFolder: sourceFolder2,
-          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(sourceFolder2, 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: appRoot2,
-          sourceFolder: sourceFolder2
-        }).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(appRoot2, e)
-        )
-      };
-      return {
-        kind: "apiRoute",
-        entry
-      };
-    };
-    return { name, handler };
-  };
-};
-
-// src/routes-factory/index.ts
-var routesFactory = async (pluginOptions) => {
-  const { appRoot: appRoot2, sourceFolder: sourceFolder2 } = pluginOptions;
-  const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
-  const apiUseResolver = apiUseResolverFactory(pluginOptions);
-  const pageRouteResolver = pageRouteResolverFactory(pluginOptions);
-  const pageLayoutResolver = pageLayoutResolverFactory(pluginOptions);
-  const resolversFactory2 = (routeFiles2) => {
-    const resolvers2 = /* @__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)) {
-          resolvers2.set(entry.fileFullpath, apiRouteResolver(entry));
-        } else if (isApiUse(entry.file)) {
-          resolvers2.set(entry.fileFullpath, apiUseResolver(entry));
-        }
-      } else if (entry.folder === defaults.pagesDir) {
-        if (isPageRoute(entry.file)) {
-          resolvers2.set(entry.fileFullpath, pageRouteResolver(entry));
-        } else if (isPageLayout(entry.file)) {
-          resolvers2.set(entry.fileFullpath, pageLayoutResolver(entry));
-        }
-      }
-    }
-    return resolvers2;
-  };
-  const routeFiles = await scanRoutes({ appRoot: appRoot2, sourceFolder: sourceFolder2 });
-  return {
-    resolvers: resolversFactory2(routeFiles),
-    resolversFactory: resolversFactory2
-  };
-};
-
-// src/base-plugin/worker.ts
-var { generatorModules, ...restOptions } = workerData;
-var generators = [];
-for (const [path, opts] of generatorModules) {
-  generators.push(await import(path).then((m) => m.default(opts)));
-}
-var resolvedOptions = {
-  ...restOptions,
-  generators
-};
-var { appRoot, sourceFolder } = resolvedOptions;
-var watchHandlers = [];
-var resolvedEntries = /* @__PURE__ */ new Map();
-var { resolvers, resolversFactory } = await routesFactory(resolvedOptions);
-var spinnerFactory = (startText) => {
-  const id = [startText, Date.now().toString()].map(crc6).join(":");
-  const postMessage = (method, text) => {
-    const spinner = { id, startText, method, text };
-    parentPort?.postMessage({ spinner });
-  };
-  const postError = (error) => {
-    parentPort?.postMessage({ error: structuredClone(error) });
-  };
-  return {
-    id,
-    startText,
-    text(text) {
-      postMessage("text", text);
-    },
-    append(text) {
-      postMessage("append", text);
-    },
-    succeed(text) {
-      postMessage("succeed", text);
-    },
-    failed(error) {
-      postError(error);
-      postMessage("failed", error?.stack || error?.message);
-    }
-  };
-};
-var createEventHandler = async (file) => {
-  const [resolver] = resolversFactory([file]).values();
-  if (resolver) {
-    const spinner = spinnerFactory(`Resolving ${resolver.name} Route`);
-    try {
-      const resolvedEntry = await resolver.handler();
-      resolvers.set(file, resolver);
-      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
-      spinner.succeed();
-    } catch (error) {
-      spinner.failed(error);
-    }
-  }
-};
-var updateEventHandler = async (file) => {
-  const relatedResolvers = /* @__PURE__ */ new Map();
-  if (resolvedEntries.has(file)) {
-    const resolver = resolvers.get(file);
-    if (resolver) {
-      relatedResolvers.set(file, resolver);
-    }
-  } else {
-    const referencedRoutes = resolvedEntries.values().flatMap(({ kind, entry }) => {
-      return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
-    });
-    for (const route of referencedRoutes) {
-      const resolver = resolvers.get(route.fileFullpath);
-      if (resolver) {
-        relatedResolvers.set(route.fileFullpath, resolver);
-      }
-    }
-  }
-  let spinner = spinnerFactory(`Updating ${relatedResolvers.size} Routes`);
-  for (const resolver of relatedResolvers.values()) {
-    spinner.append(resolver.name);
-    try {
-      const resolvedEntry = await resolver.handler(file);
-      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
-    } catch (error) {
-      spinner.failed(error);
-      spinner = spinnerFactory(`Updating ${relatedResolvers.size} Routes`);
-    }
-  }
-  spinner.succeed();
-};
-var deleteEventHandler = async () => {
-};
-var runWatchHandlers = async (event) => {
-  let spinner = spinnerFactory("Running Generators");
-  const entries = Array.from(resolvedEntries.values());
-  for (const { name, handler } of watchHandlers) {
-    spinner.append(name);
-    try {
-      await handler(structuredClone(entries), event);
-    } catch (error) {
-      spinner.failed(error);
-      spinner = spinnerFactory("Running Generators");
-    }
-  }
-  spinner.succeed();
-};
-var { createPath } = pathResolver({ appRoot, sourceFolder });
-var watcher = chokidar.watch(
-  [
-    // watching for changes in sourceFolder's apiDir and pagesDir
-    createPath.api(),
-    createPath.pages()
-  ],
-  {
-    ...resolvedOptions.watcher.options,
-    awaitWriteFinish: typeof resolvedOptions.watcher.options?.awaitWriteFinish === "object" ? resolvedOptions.watcher.options.awaitWriteFinish : {
-      stabilityThreshold: resolvedOptions.watcher.delay,
-      pollInterval: Math.floor(resolvedOptions.watcher.delay / 4)
-    },
-    // Do Not emit "add" event for existing files
-    ignoreInitial: true
-    // Not using Chokidar's `ignored` option.
-    // Instead, allow all events through and filter them manually as needed.
-  }
-);
-watcher.on("all", async (event, file) => {
-  if (event.endsWith("Dir")) {
-    return;
-  }
-  if (!isRouteFile(file, { appRoot, sourceFolder })) {
-    return;
-  }
-  const match = {
-    add: { handler: createEventHandler, kind: "create" },
-    change: { handler: updateEventHandler, kind: "update" },
-    unlink: { handler: deleteEventHandler, kind: "delete" }
-  }[event];
-  if (match) {
-    const { handler, kind } = match;
-    await handler(file);
-    await runWatchHandlers({ kind, file });
-  }
-});
-{
-  let spinner = spinnerFactory("Resolving Routes");
-  for (const { name, handler } of resolvers.values()) {
-    spinner.append(
-      `[ ${resolvedEntries.size + 1} of ${resolvers.size} ] ${name}`
-    );
-    try {
-      const resolvedEntry = await handler();
-      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
-    } catch (error) {
-      spinner.failed(error);
-      spinner = spinnerFactory("Resolving Routes");
-    }
-  }
-  spinner.succeed();
-}
-{
-  let spinner = spinnerFactory("Initializing Generators");
-  for (const { name, factory } of generators) {
-    spinner.append(name);
-    try {
-      const { watch } = await factory(resolvedOptions);
-      watchHandlers.push({ name, handler: watch });
-    } catch (error) {
-      spinner.failed(error);
-      spinner = spinnerFactory("Initializing Generators");
-    }
-  }
-  spinner.succeed();
-}
-await runWatchHandlers();
-parentPort?.postMessage("ready");
-//# sourceMappingURL=worker.js.map