@kosmojs/dev 0.0.0

package/pkg/base-plugin/worker.js

@@ -0,0 +1,810 @@
+// src/base-plugin/worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+import chokidar from "chokidar";
+import crc4 from "crc/crc32";
+import {
+  pathResolver as pathResolver3
+} from "@kosmojs/devlib";
+
+// src/base-plugin/routes.ts
+import { dirname, join, resolve as resolve3 } from "node:path";
+import crc3 from "crc/crc32";
+import picomatch from "picomatch";
+import { glob } from "tinyglobby";
+import {
+  defaults,
+  pathResolver as pathResolver2,
+  pathTokensFactory,
+  render,
+  renderToFile
+} from "@kosmojs/devlib";
+
+// src/base-plugin/ast.ts
+import { resolve } from "node:path";
+import crc from "crc/crc32";
+import { flattener } from "tfusion";
+import {
+  Project,
+  SyntaxKind
+} from "ts-morph";
+import { HTTPMethods } from "@kosmojs/api";
+var createProject = (opts) => new Project(opts);
+var resolveRouteSignature = async (route, opts) => {
+  const {
+    sourceFile = createProject().addSourceFileAtPath(route.fileFullpath)
+  } = { ...opts };
+  const [typeDeclarations, referencedFiles] = extractTypeDeclarations(
+    sourceFile,
+    opts
+  );
+  const defaultExport = extractDefaultExport(sourceFile);
+  const paramsRefinements = defaultExport ? extractParamsRefinements(defaultExport) : void 0;
+  const methods = defaultExport ? extractRouteMethods(defaultExport, route) : [];
+  const payloadTypes = methods.flatMap((e) => {
+    return e.payloadType ? [e.payloadType] : [];
+  });
+  const responseTypes = methods.flatMap((e) => {
+    return e.responseType ? [e.responseType] : [];
+  });
+  return {
+    typeDeclarations,
+    paramsRefinements,
+    methods: methods.map((e) => e.method),
+    payloadTypes,
+    responseTypes,
+    referencedFiles
+  };
+};
+var extractDefaultExport = (sourceFile) => {
+  const [defaultExport] = sourceFile.getExportAssignments().flatMap((exportAssignment) => {
+    if (exportAssignment.isExportEquals()) {
+      return [];
+    }
+    const callExpression = exportAssignment.getExpression();
+    return callExpression.isKind(SyntaxKind.CallExpression) ? [callExpression] : [];
+  });
+  return defaultExport;
+};
+var extractParamsRefinements = (callExpression) => {
+  const [firstGeneric] = extractGenerics(callExpression);
+  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
+    return;
+  }
+  const tupleElements = firstGeneric.node.getElements();
+  if (!tupleElements?.length) {
+    return;
+  }
+  return tupleElements.map((node, index) => {
+    return {
+      index,
+      text: node.getText()
+    };
+  });
+};
+var extractRouteMethods = (callExpression, route) => {
+  const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
+  if (!funcDeclaration) {
+    return [];
+  }
+  const arrayLiteralExpression = funcDeclaration.getFirstChildByKind(
+    SyntaxKind.ArrayLiteralExpression
+  );
+  if (!arrayLiteralExpression) {
+    return [];
+  }
+  const callExpressions = [];
+  for (const e of arrayLiteralExpression.getChildrenOfKind(
+    SyntaxKind.CallExpression
+  )) {
+    const name = e.getExpression().getText();
+    if (HTTPMethods[name]) {
+      callExpressions.push([e, name]);
+    }
+  }
+  const methods = [];
+  const skipValidationFilter = (e) => /@skip-validation/.test(e);
+  for (const [callExpression2, method] of callExpressions) {
+    const [payloadGeneric, responseGeneric] = extractGenerics(callExpression2);
+    const payloadText = payloadGeneric?.node ? payloadGeneric.node.getChildren().length === 0 ? "{}" : payloadGeneric.node.getFullText() : void 0;
+    const responseText = responseGeneric?.node.getText();
+    const responseType = responseText ? {
+      id: ["ResponseT", crc(route.importName + method)].join(""),
+      method,
+      skipValidation: responseGeneric?.comments ? responseGeneric.comments.some(skipValidationFilter) : false,
+      text: ["never", "object"].includes(responseText) ? "{}" : responseText,
+      resolvedType: void 0
+    } : void 0;
+    const payloadType = payloadText ? {
+      id: ["PayloadT", crc(route.importName + method)].join(""),
+      responseTypeId: responseType?.id,
+      method,
+      skipValidation: payloadGeneric?.comments ? payloadGeneric.comments.some(skipValidationFilter) : false,
+      isOptional: payloadText ? payloadText === "{}" || route.optionalParams : true,
+      text: payloadText,
+      resolvedType: void 0
+    } : void 0;
+    methods.push({
+      method,
+      payloadType,
+      responseType
+    });
+  }
+  return methods;
+};
+var extractTypeDeclarations = (sourceFile, opts) => {
+  const declarations = [];
+  const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
+  for (const declaration of sourceFile.getImportDeclarations()) {
+    const modulePath = declaration.getModuleSpecifierValue();
+    const path = /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath;
+    const typeOnlyDeclaration = declaration.isTypeOnly();
+    const defaultImport = typeOnlyDeclaration ? declaration.getDefaultImport() : void 0;
+    if (defaultImport) {
+      const name = defaultImport.getText();
+      const text = `import type ${name} from "${path}";`;
+      declarations.push({
+        importDeclaration: {
+          name,
+          path
+        },
+        text
+      });
+      if (referencedFiles) {
+        referencedFiles.push(...getReferencedFiles(defaultImport));
+      }
+    }
+    for (const namedImport of declaration.getNamedImports()) {
+      if (namedImport.isTypeOnly() || typeOnlyDeclaration) {
+        const nameNode = namedImport.getNameNode();
+        const name = nameNode.getText();
+        const alias = namedImport.getAliasNode()?.getText();
+        const nameText = alias ? `${name} as ${alias}` : name;
+        declarations.push({
+          importDeclaration: {
+            name,
+            alias,
+            path
+          },
+          text: `import type { ${nameText} } from "${path}";`
+        });
+        if (referencedFiles) {
+          if (nameNode.isKind(SyntaxKind.Identifier)) {
+            referencedFiles.push(...getReferencedFiles(nameNode));
+          }
+        }
+      }
+    }
+  }
+  for (const declaration of sourceFile.getTypeAliases()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      typeAliasDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getInterfaces()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      interfaceDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getEnums()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      enumDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getExportDeclarations()) {
+    const typeOnlyDeclaration = declaration.isTypeOnly();
+    const modulePath = declaration.getModuleSpecifierValue();
+    const path = modulePath ? /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath : void 0;
+    for (const namedExport of declaration.getNamedExports()) {
+      if (namedExport.isTypeOnly() || typeOnlyDeclaration) {
+        const nameNode = namedExport.getNameNode();
+        const name = nameNode.getText();
+        const alias = namedExport.getAliasNode()?.getText();
+        const nameText = alias ? `${name} as ${alias}` : name;
+        declarations.push({
+          exportDeclaration: {
+            name,
+            alias: alias ?? name,
+            path
+          },
+          text: path ? `export type { ${nameText} } from "${path}";` : `export type { ${nameText} };`
+        });
+        if (referencedFiles) {
+          if (nameNode.isKind(SyntaxKind.Identifier)) {
+            referencedFiles.push(...getReferencedFiles(nameNode));
+          }
+        }
+      }
+    }
+  }
+  return referencedFiles ? [declarations, [...new Set(referencedFiles)]] : [declarations];
+};
+var getReferencedFiles = (importIdentifier) => {
+  const declarations = importIdentifier?.getSymbol()?.getAliasedSymbol()?.getDeclarations() || [];
+  return declarations.flatMap((e) => {
+    const sourceFile = e.getSourceFile();
+    return sourceFile ? [sourceFile.getFilePath()] : [];
+  });
+};
+var extractGenerics = (callExpression) => {
+  return callExpression.getTypeArguments().map((node) => {
+    return {
+      node,
+      comments: node.getLeadingCommentRanges().map((range) => range.getText().trim())
+    };
+  });
+};
+var typeResolverFactory = ({ appRoot: 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/base-plugin/cache.ts
+import { resolve as resolve2 } from "node:path";
+import crc2 from "crc/crc32";
+import fsx from "fs-extra";
+import pkg from "@kosmojs/dev/package.json" with { type: "json" };
+import { pathResolver } from "@kosmojs/devlib";
+var cacheFactory = (route, {
+  appRoot: appRoot2,
+  sourceFolder: sourceFolder2,
+  extraContext
+}) => {
+  const cacheFile = pathResolver({
+    appRoot: appRoot2,
+    sourceFolder: sourceFolder2
+  }).resolve("apiLibDir", route.importPath, "cache.json");
+  const getCache = async (opt) => {
+    if (await fsx.exists(cacheFile)) {
+      try {
+        const cache = JSON.parse(await fsx.readFile(cacheFile, "utf8"));
+        return opt?.validate ? validateCache(cache) : cache;
+      } catch (_e) {
+      }
+    }
+    return void 0;
+  };
+  const persistCache = async ({
+    referencedFiles: _referencedFiles,
+    ...rest
+  }) => {
+    const hash = await generateFileHash(route.fileFullpath, {
+      ...extraContext
+    });
+    const referencedFiles = {};
+    for (const file of _referencedFiles) {
+      referencedFiles[
+        // Strip project root to ensure cached paths are relative
+        // and portable across environments (CI, local, etc.)
+        file.replace(`${appRoot2}/`, "")
+      ] = await generateFileHash(file);
+    }
+    const cache = { ...rest, hash, referencedFiles };
+    await fsx.outputJson(cacheFile, cache, { spaces: 2 });
+    return cache;
+  };
+  const validateCache = async (cache) => {
+    if (!cache?.hash) {
+      return;
+    }
+    if (!cache.typeDeclarations || !cache.referencedFiles) {
+      return;
+    }
+    const hash = await generateFileHash(route.fileFullpath, {
+      ...extraContext
+    });
+    if (!identicalHashSum(cache.hash, hash)) {
+      return;
+    }
+    for (const [file, hash2] of Object.entries(cache.referencedFiles)) {
+      if (!identicalHashSum(hash2, await generateFileHash(resolve2(appRoot2, file)))) {
+        return;
+      }
+    }
+    return cache;
+  };
+  return {
+    getCache,
+    validateCache,
+    persistCache
+  };
+};
+var generateFileHash = async (file, extraContext) => {
+  let fileContent;
+  try {
+    fileContent = await fsx.readFile(file, "utf8");
+  } catch (_e) {
+    return 0;
+  }
+  return fileContent ? crc2(
+    JSON.stringify({
+      ...extraContext,
+      [pkg.cacheVersion]: fileContent
+    })
+  ) : 0;
+};
+var identicalHashSum = (a, b) => {
+  return a === b;
+};
+
+// src/base-plugin/templates/resolved-types.hbs
+var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
+
+// src/base-plugin/templates/types.hbs
+var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}:{{#if isRest}} Array<{{/if}}\n    {{#if refinement}}{{refinement.text}}{{else}}string{{/if}}\n  {{#if isRest}}>{{/if}}\n  {{/each}}\n};\n\n{{#each payloadTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n\n{{#each responseTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n';
+
+// src/base-plugin/routes.ts
+var routes_default = async (pluginOptions) => {
+  const {
+    appRoot: appRoot2,
+    sourceFolder: sourceFolder2,
+    generators: generators2 = [],
+    formatters: formatters2 = [],
+    refineTypeName
+  } = pluginOptions;
+  let resolveTypes = false;
+  for (const { options } of generators2) {
+    if (options?.resolveTypes) {
+      resolveTypes = true;
+    }
+  }
+  const {
+    //
+    literalTypesResolver,
+    getSourceFile,
+    refreshSourceFile
+  } = typeResolverFactory(pluginOptions);
+  const routeFilePatterns = [
+    `${defaults.apiDir}/**/index.ts`,
+    `${defaults.pagesDir}/**/index.{ts,tsx,vue,svelte}`
+  ];
+  const resolveRouteFile2 = (file) => {
+    const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/`, "").split("/");
+    if (!folder || _sourceFolder !== sourceFolder2 || rest.length < 2) {
+      return;
+    }
+    return picomatch.isMatch(join(folder, ...rest), routeFilePatterns) ? [folder, rest.join("/")] : void 0;
+  };
+  const resolversFactory2 = (routeFiles2) => {
+    const resolvers2 = /* @__PURE__ */ new Map();
+    const entries = routeFiles2.flatMap((_file) => {
+      const resolvedPaths = resolveRouteFile2(_file);
+      if (!resolvedPaths) {
+        return [];
+      }
+      const [folder, file] = resolvedPaths;
+      const fileFullpath = join(appRoot2, sourceFolder2, folder, file);
+      const pathTokens = pathTokensFactory(dirname(file));
+      const name = pathTokens.map((e) => e.orig).join("/");
+      const importPath = dirname(file);
+      const importName = [
+        importPath.split(/\[/)[0].replace(/^\W+|\W+$/g, "").replace(/\W+/g, "_"),
+        crc3(importPath)
+      ].join("_");
+      return [
+        {
+          name,
+          folder,
+          file,
+          fileFullpath,
+          pathTokens,
+          importPath,
+          importName
+        }
+      ];
+    });
+    for (const entry of entries.filter((e) => e.folder === defaults.apiDir)) {
+      const {
+        name,
+        file,
+        folder,
+        fileFullpath,
+        pathTokens,
+        importPath,
+        importName
+      } = entry;
+      const handler = async (updatedFile) => {
+        const paramsSchema = pathTokens.flatMap((e) => {
+          return e.param ? [e.param] : [];
+        });
+        const optionalParams = paramsSchema.length ? !paramsSchema.some((e) => e.isRequired) : true;
+        const { getCache, persistCache } = cacheFactory(
+          { file, fileFullpath, importName, importPath },
+          {
+            appRoot: appRoot2,
+            sourceFolder: sourceFolder2,
+            extraContext: { resolveTypes }
+          }
+        );
+        let cache = await getCache({ validate: true });
+        if (!cache) {
+          if (updatedFile === fileFullpath) {
+            await refreshSourceFile(fileFullpath);
+          }
+          const {
+            typeDeclarations,
+            paramsRefinements,
+            methods,
+            payloadTypes,
+            responseTypes,
+            referencedFiles = []
+          } = await resolveRouteSignature(
+            { importName, fileFullpath, optionalParams },
+            {
+              withReferencedFiles: true,
+              sourceFile: getSourceFile(fileFullpath),
+              relpathResolver(path) {
+                return join(sourceFolder2, defaults.apiDir, dirname(file), path);
+              }
+            }
+          );
+          const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
+            if (text === "number") {
+              const param = paramsSchema.at(index);
+              return param ? [param.name] : [];
+            }
+            return [];
+          }) : [];
+          const typesFile = pathResolver2({ appRoot: appRoot2, sourceFolder: sourceFolder2 }).resolve(
+            "apiLibDir",
+            importPath,
+            "types.ts"
+          );
+          const params = {
+            id: ["ParamsT", crc3(name)].join(""),
+            schema: paramsSchema,
+            resolvedType: void 0
+          };
+          const typesFileContent = render(types_default, {
+            params,
+            paramsSchema: paramsSchema.map((param, index) => {
+              return {
+                ...param,
+                refinement: paramsRefinements?.at(index)
+              };
+            }),
+            typeDeclarations,
+            payloadTypes,
+            responseTypes
+          });
+          const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
+            overrides: [...payloadTypes, ...responseTypes].reduce(
+              (map, { id, skipValidation }) => {
+                if (skipValidation) {
+                  map[id] = "never";
+                }
+                return map;
+              },
+              { [refineTypeName]: refineTypeName }
+            ),
+            withProperties: [params.id, ...payloadTypes.map((e) => e.id)],
+            formatters: formatters2
+          }) : void 0;
+          await renderToFile(
+            typesFile,
+            resolvedTypes ? resolved_types_default : typesFileContent,
+            { resolvedTypes }
+          );
+          params.resolvedType = resolvedTypes?.find(
+            (e) => e.name === params.id
+          );
+          cache = await persistCache({
+            params,
+            methods,
+            typeDeclarations,
+            numericParams,
+            // text was needed at writing types.ts file, dropping from cache
+            payloadTypes: payloadTypes.map(({ text, ...rest }) => {
+              return {
+                ...rest,
+                resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
+              };
+            }),
+            responseTypes: responseTypes.map(({ text, ...rest }) => {
+              return {
+                ...rest,
+                resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
+              };
+            }),
+            referencedFiles
+          });
+        }
+        const route = {
+          name,
+          pathTokens,
+          params: cache.params,
+          numericParams: cache.numericParams,
+          optionalParams,
+          importName,
+          importPath,
+          folder,
+          file,
+          fileFullpath,
+          methods: cache.methods,
+          typeDeclarations: cache.typeDeclarations,
+          payloadTypes: cache.payloadTypes,
+          responseTypes: cache.responseTypes,
+          referencedFiles: Object.keys(cache.referencedFiles).map(
+            // expand referenced files path,
+            // they are stored as relative in cache
+            (e) => resolve3(appRoot2, e)
+          )
+        };
+        return {
+          kind: "api",
+          route
+        };
+      };
+      resolvers2.set(fileFullpath, { name, handler });
+    }
+    for (const entry of entries.filter((e) => e.folder === defaults.pagesDir)) {
+      const {
+        //
+        name,
+        folder,
+        file,
+        fileFullpath,
+        pathTokens,
+        importPath,
+        importName
+      } = entry;
+      const handler = async () => {
+        const route = {
+          name,
+          pathTokens,
+          params: {
+            schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
+          },
+          folder,
+          file,
+          fileFullpath,
+          importPath,
+          importName
+        };
+        return {
+          kind: "page",
+          route
+        };
+      };
+      resolvers2.set(fileFullpath, { name, handler });
+    }
+    return resolvers2;
+  };
+  const routeFiles = await glob(routeFilePatterns, {
+    cwd: resolve3(appRoot2, sourceFolder2),
+    absolute: true,
+    onlyFiles: true,
+    ignore: [
+      `${defaults.apiDir}/index.ts`,
+      `${defaults.pagesDir}/index.ts{x,}`
+    ]
+  });
+  return {
+    resolvers: resolversFactory2(routeFiles),
+    resolversFactory: resolversFactory2,
+    resolveRouteFile: resolveRouteFile2
+  };
+};
+
+// src/base-plugin/worker.ts
+var {
+  //
+  generatorModules,
+  formatterModules,
+  ...restOptions
+} = workerData;
+var generators = [];
+var formatters = [];
+for (const [path, opts] of generatorModules) {
+  generators.push(await import(path).then((m) => m.default(opts)));
+}
+for (const [path, opts] of formatterModules) {
+  formatters.push(await import(path).then((m) => m.default(opts).formatter));
+}
+var resolvedOptions = {
+  ...restOptions,
+  generators,
+  formatters
+};
+var { appRoot, sourceFolder } = resolvedOptions;
+var watchHandlers = [];
+var resolvedRoutes = /* @__PURE__ */ new Map();
+var {
+  //
+  resolvers,
+  resolversFactory,
+  resolveRouteFile
+} = await routes_default(resolvedOptions);
+var { resolve: resolve4 } = pathResolver3({ appRoot, sourceFolder });
+var spinnerFactory = (startText) => {
+  const id = [startText, Date.now().toString()].map(crc4).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 resolvedRoute = await resolver.handler();
+      resolvers.set(file, resolver);
+      resolvedRoutes.set(resolvedRoute.route.fileFullpath, resolvedRoute);
+      spinner.succeed();
+    } catch (error) {
+      spinner.failed(error);
+    }
+  }
+};
+var updateEventHandler = async (file) => {
+  const relatedResolvers = /* @__PURE__ */ new Map();
+  if (resolvedRoutes.has(file)) {
+    const resolver = resolvers.get(file);
+    if (resolver) {
+      relatedResolvers.set(file, resolver);
+    }
+  } else {
+    const referencedRoutes = resolvedRoutes.values().filter(({ kind, route }) => {
+      return kind === "api" ? route.referencedFiles.includes(file) : false;
+    });
+    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 route = await resolver.handler(file);
+      resolvedRoutes.set(route.route.fileFullpath, route);
+    } 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 routes = Array.from(resolvedRoutes.values());
+  for (const { name, handler } of watchHandlers) {
+    spinner.append(name);
+    try {
+      await handler(structuredClone(routes), event);
+    } catch (error) {
+      spinner.failed(error);
+      spinner = spinnerFactory("Running Generators");
+    }
+  }
+  spinner.succeed();
+};
+var watcher = chokidar.watch(
+  [
+    // watching for changes in sourceFolder's apiDir and pagesDir
+    resolve4("apiDir"),
+    resolve4("pagesDir")
+  ],
+  {
+    ...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 (!resolveRouteFile(file)) {
+    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(
+      `[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`
+    );
+    try {
+      const resolvedEntry = await handler();
+      resolvedRoutes.set(resolvedEntry.route.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 { watchHandler } = await factory(resolvedOptions);
+      watchHandlers.push({ name, handler: watchHandler });
+    } catch (error) {
+      spinner.failed(error);
+      spinner = spinnerFactory("Initializing Generators");
+    }
+  }
+  spinner.succeed();
+}
+await runWatchHandlers();
+parentPort?.postMessage("ready");
+//# sourceMappingURL=worker.js.map