@kosmojs/dev 0.0.25 → 0.0.27

package/pkg/chassis.js

@@ -0,0 +1,636 @@
+// src/chassis.ts
+import http from "node:http";
+import net from "node:net";
+import { join, resolve as resolve2 } from "node:path";
+import { styleText } from "node:util";
+import { build, createServer } from "vite";
+import {
+  defaults,
+  pathResolver as pathResolver3,
+  routesFactory,
+  spinnerFactory
+} from "@kosmojs/lib";
+
+// src/cache.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import crc from "crc/crc32";
+import self from "@kosmojs/dev/package.json" with { type: "json" };
+import { pathExists, pathResolver } from "@kosmojs/lib";
+var cacheFactory = (route, sourceFolder, extraContext) => {
+  const cacheFile = pathResolver(sourceFolder).createPath.libApi(
+    dirname(route.file),
+    "cache.json"
+  );
+  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(resolve(sourceFolder.root, file))
+      )) {
+        return;
+      }
+    }
+    return cache;
+  };
+  return {
+    async get(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;
+    },
+    async set(cache) {
+      const hash = await generateFileHash(route.fileFullpath, {
+        ...extraContext
+      });
+      const referencedFiles = {};
+      for (const file of cache.referencedFiles) {
+        referencedFiles[
+          // Strip project root to ensure cached paths are relative
+          // and portable across environments (CI, local, etc.)
+          file.replace(`${sourceFolder.root}/`, "")
+        ] = await generateFileHash(file);
+      }
+      const value = { ...cache, hash, referencedFiles };
+      await mkdir(dirname(cacheFile), { recursive: true });
+      await writeFile(cacheFile, JSON.stringify(value, null, 2), "utf8");
+      return value;
+    }
+  };
+};
+var generateFileHash = async (file, extraContext) => {
+  let fileContent;
+  try {
+    fileContent = await readFile(file, "utf8");
+  } catch (_e) {
+    return 0;
+  }
+  return fileContent ? crc(
+    JSON.stringify({
+      ...extraContext,
+      [self.cacheVersion]: fileContent
+    })
+  ) : 0;
+};
+var identicalHashSum = (a, b) => {
+  return a === b;
+};
+
+// src/core-generator/index.ts
+import { dirname as dirname2 } from "node:path";
+import {
+  defineGenerator,
+  defineGeneratorFactory,
+  generateTsconfig,
+  pathResolver as pathResolver2,
+  renderToFile
+} from "@kosmojs/lib";
+
+// src/templates/env.d.ts
+var env_d_default = 'declare const KOSMO_PRODUCTION_BUILD: boolean;\n\n/**\n * Enhances base TypeScript types with JSON Schema validation constraints.\n * Allows declaring refined types that carry validation metadata for runtime\n * schema validation while maintaining full TypeScript type safety.\n *\n * Useful for generating validation schemas and ensuring\n * data conforms to specific business rules beyond basic type checking.\n * */\ndeclare type VRefine<\n  T extends unknown[] | number | string | object,\n  _ extends T extends unknown[]\n    ? TArrayOptions\n    : T extends number\n      ? TNumberOptions\n      : T extends string\n        ? TStringOptions\n        : TObjectOptions,\n> = T;\n\n/**\n * Type definitions inspired by and gently adapted from TypeBox.\n * Original TypeBox created by sinclairzx81: https://github.com/sinclairzx81/typebox\n * TypeBox is licensed under MIT: https://github.com/sinclairzx81/typebox/blob/main/license\n *\n * These types provide JSON Schema compatible type refinements for TypeScript.\n * */\ninterface TSchema {}\n\n// ------------------------------------------------------------------\n// ObjectOptions\n// ------------------------------------------------------------------\ninterface TObjectOptions {\n  /**\n   * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.\n   */\n  additionalProperties?: TSchema | boolean;\n  /**\n   * The minimum number of properties required in the object.\n   */\n  minProperties?: number;\n  /**\n   * The maximum number of properties allowed in the object.\n   */\n  maxProperties?: number;\n  /**\n   * Defines conditional requirements for properties.\n   */\n  dependencies?: Record<string, boolean | TSchema | string[]>;\n  /**\n   * Specifies properties that *must* be present if a given property is present.\n   */\n  dependentRequired?: Record<string, string[]>;\n  /**\n   * Defines schemas that apply if a specific property is present.\n   */\n  dependentSchemas?: Record<string, TSchema>;\n  /**\n   * Maps regular expressions to schemas properties matching a pattern must validate against the schema.\n   */\n  patternProperties?: Record<string, TSchema>;\n  /**\n   * A schema that all property names within the object must validate against.\n   */\n  propertyNames?: TSchema;\n}\n\n// ------------------------------------------------------------------\n// ArrayOptions\n// ------------------------------------------------------------------\ninterface TArrayOptions {\n  /**\n   * The minimum number of items allowed in the array.\n   */\n  minItems?: number;\n  /**\n   * The maximum number of items allowed in the array.\n   */\n  maxItems?: number;\n  /**\n   * A schema that at least one item in the array must validate against.\n   */\n  contains?: TSchema;\n  /**\n   * The minimum number of array items that must validate against the `contains` schema.\n   */\n  minContains?: number;\n  /**\n   * The maximum number of array items that may validate against the `contains` schema.\n   */\n  maxContains?: number;\n  /**\n   * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.\n   */\n  prefixItems?: TSchema[];\n  /**\n   * If `true`, all items in the array must be unique.\n   */\n  uniqueItems?: boolean;\n}\n\n// ------------------------------------------------------------------\n// NumberOptions\n// ------------------------------------------------------------------\ninterface TNumberOptions {\n  /**\n   * Specifies an exclusive upper limit for the number (number must be less than this value).\n   */\n  exclusiveMaximum?: number | bigint;\n  /**\n   * Specifies an exclusive lower limit for the number (number must be greater than this value).\n   */\n  exclusiveMinimum?: number | bigint;\n  /**\n   * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).\n   */\n  maximum?: number | bigint;\n  /**\n   * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).\n   */\n  minimum?: number | bigint;\n  /**\n   * Specifies that the number must be a multiple of this value.\n   */\n  multipleOf?: number | bigint;\n}\n\n// ------------------------------------------------------------------\n// StringOptions\n// ------------------------------------------------------------------\ntype TFormat =\n  | "date-time"\n  | "date"\n  | "duration"\n  | "email"\n  | "hostname"\n  | "idn-email"\n  | "idn-hostname"\n  | "ipv4"\n  | "ipv6"\n  | "iri-reference"\n  | "iri"\n  | "json-pointer-uri-fragment"\n  | "json-pointer"\n  | "json-string"\n  | "regex"\n  | "relative-json-pointer"\n  | "time"\n  | "uri-reference"\n  | "uri-template"\n  | "url"\n  | "uuid";\n\ninterface TStringOptions {\n  /**\n   * Specifies the expected string format.\n   *\n   * Common values include:\n   * - `base64` \u2013 Base64-encoded string.\n   * - `date-time` \u2013 [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.\n   * - `date` \u2013 [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).\n   * - `duration` \u2013 [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.\n   * - `email` \u2013 RFC 5321/5322 compliant email address.\n   * - `hostname` \u2013 RFC 1034/1035 compliant host name.\n   * - `idn-email` \u2013 Internationalized email address.\n   * - `idn-hostname` \u2013 Internationalized host name.\n   * - `ipv4` \u2013 IPv4 address.\n   * - `ipv6` \u2013 IPv6 address.\n   * - `iri` / `iri-reference` \u2013 Internationalized Resource Identifier.\n   * - `json-pointer` / `json-pointer-uri-fragment` \u2013 JSON Pointer format.\n   * - `json-string` \u2013 String containing valid JSON.\n   * - `regex` \u2013 Regular expression syntax.\n   * - `relative-json-pointer` \u2013 Relative JSON Pointer format.\n   * - `time` \u2013 [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).\n   * - `uri-reference` / `uri-template` \u2013 URI reference or template.\n   * - `url` \u2013 Web URL format.\n   * - `uuid` \u2013 RFC 4122 UUID string.\n   *\n   * May also be a custom format string.\n   */\n  format?: TFormat;\n  /**\n   * Specifies the minimum number of characters allowed in the string.\n   * Must be a non-negative integer.\n   */\n  minLength?: number;\n  /**\n   * Specifies the maximum number of characters allowed in the string.\n   * Must be a non-negative integer.\n   */\n  maxLength?: number;\n  /**\n   * Specifies a regular expression pattern that the string value must match.\n   * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.\n   */\n  pattern?: string | RegExp;\n}\n';
+
+// src/templates/gitignore.hbs
+var gitignore_default = "# Ignore all files\n*\n\n# But don't ignore directories (so Git can traverse them)\n!*/\n\n# And don't ignore these files at any depth\n!cache.json\n!types.ts\n";
+
+// src/templates/schemas.hbs
+var schemas_default = '// stub schemas, specialized generators supposed to overwrite this file\nimport type { ValidationSchemas } from "@kosmojs/core/api";\nexport type { ValidationSchemas };\nexport const validationSchemas: ValidationSchemas = {};\n';
+
+// src/core-generator/index.ts
+var factory = defineGeneratorFactory((meta, sourceFolder) => {
+  const { createPath } = pathResolver2(sourceFolder);
+  const start = async () => {
+    await renderToFile(
+      createPath.lib("../tsconfig.base.json"),
+      JSON.stringify(generateTsconfig(), void 0, 2),
+      {}
+    );
+    {
+      const tsconfig = generateTsconfig(sourceFolder.name);
+      const compilerOptions = {};
+      const types = new Set(tsconfig.compilerOptions.types || []);
+      for (const { meta: meta2 } of sourceFolder.config.generators || []) {
+        if (meta2.jsxImportSource) {
+          compilerOptions.jsxImportSource = meta2.jsxImportSource;
+        }
+        for (const type of meta2.types || []) {
+          types.add(type);
+        }
+      }
+      await renderToFile(
+        createPath.lib("tsconfig.base.json"),
+        JSON.stringify(
+          {
+            ...tsconfig,
+            compilerOptions: {
+              ...tsconfig.compilerOptions,
+              ...compilerOptions,
+              types: [...types.values()]
+            }
+          },
+          void 0,
+          2
+        ),
+        {}
+      );
+    }
+    await renderToFile(createPath.lib("../env.d.ts"), env_d_default, {});
+    await renderToFile(
+      createPath.lib("../.gitignore"),
+      gitignore_default,
+      {},
+      { overwrite: false }
+    );
+    await renderToFile(createPath.lib("ssg.ts"), "export default [];", {});
+  };
+  const generateLibFiles = async (entries) => {
+    for (const { kind, entry } of entries) {
+      if (kind === "apiRoute") {
+        await renderToFile(
+          createPath.libApi(dirname2(entry.file), "schemas.ts"),
+          schemas_default,
+          { route: entry },
+          { overwrite: false }
+        );
+      }
+    }
+  };
+  return {
+    meta,
+    options: void 0,
+    start,
+    watch: generateLibFiles,
+    build: generateLibFiles
+  };
+});
+var core_generator_default = defineGenerator(() => {
+  const meta = { name: "Core" };
+  return {
+    meta,
+    options: void 0,
+    factory: (sourceFolder) => factory(meta, sourceFolder)
+  };
+});
+
+// src/chassis.ts
+var chassis_default = async (projectSettings) => {
+  const { devPort, command } = projectSettings;
+  for (const sourceFolder of projectSettings.sourceFolders) {
+    for (const base of folderGenerators(sourceFolder)) {
+      if (!base.meta?.name || typeof base.factory !== "function") {
+        throw new Error(
+          `${sourceFolder.name}: Unrecognized generator - must be created via defineGenerator()`
+        );
+      }
+      const factory2 = base.factory(sourceFolder);
+      if (!factory2.meta?.name) {
+        throw new Error(
+          `${sourceFolder.name}: ${base.meta.name} generator is missing meta property`
+        );
+      }
+      try {
+        await factory2.start?.();
+      } catch (error) {
+        console.error(
+          styleText(
+            "red",
+            `${sourceFolder.name}: ${base.meta.name} generator failed to initialize`
+          )
+        );
+        throw error;
+      }
+    }
+  }
+  if (command === "build") {
+    for (const sourceFolder of projectSettings.sourceFolders) {
+      const { config, baseurl } = sourceFolder;
+      const { createPath } = pathResolver3(sourceFolder);
+      const resolvedRoutes = [];
+      {
+        const { resolvers } = await routesFactory(sourceFolder, cacheFactory);
+        const spinner = spinnerFactory(
+          `${sourceFolder.name}: resolving routes`
+        );
+        for (const { name, handler } of resolvers.values()) {
+          spinner.append(
+            `[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`
+          );
+          resolvedRoutes.push(await handler());
+        }
+        spinner.succeed("ready \u2728");
+      }
+      const generators = folderGenerators(sourceFolder);
+      const plugins = [...config.plugins || []];
+      for (const base of generators) {
+        await base.factory(sourceFolder).build?.(resolvedRoutes);
+        plugins.push(...base.plugins?.(sourceFolder, command) || []);
+      }
+      {
+        const outDir = createPath.distDir("client");
+        await build({
+          ...config,
+          configFile: false,
+          root: createPath.src(),
+          base: join(baseurl, "/"),
+          plugins,
+          resolve: {
+            ...config.resolve,
+            tsconfigPaths: true
+          },
+          build: {
+            ...config?.build,
+            outDir,
+            manifest: true,
+            emptyOutDir: true
+          },
+          cacheDir: cacheDir(sourceFolder, command, "client")
+        });
+      }
+      const apiGenerator = generators.find((e) => e.meta.slot === "api");
+      if (apiGenerator) {
+        const dir = createPath.distDir("api");
+        const noExternal = Array.isArray(apiGenerator.options?.noExternal) ? apiGenerator.options.noExternal : generators.flatMap(({ meta }) => {
+          return Object.keys({
+            ...meta.dependencies,
+            ...meta.devDependencies
+          });
+        });
+        await build({
+          configFile: false,
+          root: createPath.src(),
+          appType: "custom",
+          plugins: [...apiGenerator.plugins?.(sourceFolder, command) || []],
+          define: {
+            ...config.define,
+            KOSMO_PRODUCTION_BUILD: "true"
+          },
+          ssr: { noExternal },
+          resolve: {
+            ...config.resolve,
+            tsconfigPaths: true,
+            conditions: ["node"]
+          },
+          build: {
+            ssr: true,
+            target: "esnext",
+            sourcemap: true,
+            emptyOutDir: true,
+            rolldownOptions: {
+              input: [createPath.api("app.ts"), createPath.api("server.ts")],
+              output: {
+                dir,
+                format: "esm"
+              }
+            }
+          },
+          cacheDir: cacheDir(sourceFolder, command, "backend")
+        });
+      }
+      for (const base of generators) {
+        await base.factory(sourceFolder).postBuild?.(resolvedRoutes);
+      }
+    }
+    return async () => {
+    };
+  }
+  const requestHandlers = [];
+  const teardownHandlers = [];
+  const eventMap = {};
+  for (const sourceFolder of projectSettings.sourceFolders) {
+    eventMap[sourceFolder.name] = await eventFactory(sourceFolder);
+  }
+  let port = await findFreePort(devPort);
+  for (const sourceFolder of projectSettings.sourceFolders) {
+    const { config, baseurl } = sourceFolder;
+    const { createPath } = pathResolver3(sourceFolder);
+    const requestMatchers = matchersFactory(sourceFolder);
+    const generators = folderGenerators(sourceFolder);
+    const plugins = [...config.plugins || []];
+    for (const base of generators) {
+      plugins.push(...base.plugins?.(sourceFolder, command) || []);
+    }
+    const viteServer = await createServer({
+      ...config,
+      configFile: false,
+      root: createPath.src(),
+      base: join(baseurl, "/"),
+      plugins,
+      server: {
+        ...config.server,
+        port: port++,
+        middlewareMode: true,
+        hmr: { port: port++ }
+      },
+      resolve: {
+        ...config.resolve,
+        tsconfigPaths: true
+      },
+      define: {
+        ...config.define
+      },
+      cacheDir: cacheDir(sourceFolder, command, "client")
+    });
+    for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) {
+      viteServer.watcher.on(evt, handler);
+    }
+    requestHandlers.push([
+      [sourceFolder.baseurl],
+      () => requestMatchers.base,
+      () => viteServer.middlewares
+    ]);
+    teardownHandlers.push(viteServer.close);
+  }
+  for (const sourceFolder of projectSettings.sourceFolders) {
+    const { config } = sourceFolder;
+    if (!folderGenerators(sourceFolder).find((e) => e.meta.slot === "api")) {
+      continue;
+    }
+    const { createPath } = pathResolver3(sourceFolder);
+    const requestMatchers = matchersFactory(sourceFolder);
+    const viteServer = await createServer({
+      configFile: false,
+      root: createPath.src(),
+      appType: "custom",
+      server: {
+        port: port++,
+        middlewareMode: true,
+        hmr: { port: port++ }
+      },
+      resolve: { tsconfigPaths: true },
+      define: {
+        ...config?.define,
+        KOSMO_PRODUCTION_BUILD: "false"
+      },
+      environments: {
+        api: {
+          resolve: {
+            conditions: ["node"]
+          }
+        }
+      },
+      cacheDir: cacheDir(sourceFolder, command, "backend")
+    });
+    const env = viteServer.environments.api;
+    const loadDevSetup = async () => {
+      env.runner.clearCache();
+      return env.runner.import(join(defaults.apiDir, "dev.ts")).then((e) => e.default);
+    };
+    let devSetup = await loadDevSetup();
+    for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) {
+      viteServer.watcher.on(evt, async (file) => {
+        const mods = env.moduleGraph.getModulesByFile(file);
+        if (mods?.size) {
+          await handler(file);
+          await devSetup?.teardownHandler?.();
+          devSetup = await loadDevSetup();
+        }
+      });
+    }
+    requestHandlers.push([
+      [sourceFolder.baseurl, sourceFolder.apiurl],
+      () => devSetup.requestMatcher || requestMatchers.api,
+      () => devSetup.requestHandler()
+    ]);
+    teardownHandlers.push(viteServer.close);
+  }
+  const requestHandlerWeight = ([
+    segments
+  ]) => {
+    const [base, api] = segments;
+    const weight = base.split("/").filter(Boolean).length;
+    return api ? weight + 5 : weight;
+  };
+  const handlers = requestHandlers.sort(
+    (a, b) => requestHandlerWeight(b) - requestHandlerWeight(a)
+  );
+  const httpServer = http.createServer((req, res) => {
+    for (const [, matcherFactory, handlerFactory] of handlers) {
+      const [matcher, handler] = [matcherFactory(), handlerFactory()];
+      if (matcher(req)) {
+        handler(req, res);
+        return;
+      }
+    }
+    res.writeHead(404, { "Content-Type": "text/html" });
+    res.end("<h1>404: Not Found</h1>");
+  });
+  httpServer.on("error", (error) => {
+    console.error(
+      styleText("red", `Failed to start dev server on port ${devPort}`)
+    );
+    console.error(error.message);
+    process.exit(1);
+  });
+  httpServer.listen(devPort);
+  teardownHandlers.push(async () => {
+    httpServer.close();
+  });
+  return async () => {
+    for (const handler of teardownHandlers) {
+      await handler().catch(console.error);
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
+  };
+};
+var cacheDir = ({ root, name }, command, mode) => {
+  return resolve2(root, `var/.vite/${name}/${command}/${mode}`);
+};
+var folderGenerators = (sourceFolder) => {
+  const { generators = [] } = sourceFolder.config;
+  const coreGenerators = {};
+  const userGenerators = [];
+  for (const base of generators) {
+    if (base.meta.slot) {
+      coreGenerators[base.meta.slot] = base;
+    } else {
+      userGenerators.push(base);
+    }
+  }
+  return [
+    // core generator should run first
+    core_generator_default(),
+    // then api generator
+    ...coreGenerators.api ? [coreGenerators.api] : [],
+    // then fetch generator, only if api generator also enabled
+    ...coreGenerators.fetch && coreGenerators.api ? [coreGenerators.fetch] : [],
+    // then user generators in the order they were added
+    ...userGenerators,
+    // then ssr generator should run after user generators
+    ...coreGenerators.ssr ? [coreGenerators.ssr] : [],
+    // and ssg generator should run last
+    ...coreGenerators.ssg ? [coreGenerators.ssg] : []
+  ];
+};
+var eventFactory = async (sourceFolder) => {
+  const { resolvers, resolversFactory } = await routesFactory(
+    sourceFolder,
+    cacheFactory
+  );
+  const { createPath } = pathResolver3(sourceFolder);
+  const generators = [];
+  for (const base of folderGenerators(sourceFolder)) {
+    const factory2 = base.factory(sourceFolder);
+    generators.push({ name: base.meta.name, factory: factory2 });
+  }
+  const resolvedRoutes = /* @__PURE__ */ new Map();
+  const runGenerators = async (event) => {
+    const entries = Array.from(resolvedRoutes.values());
+    for (const { name, factory: factory2 } of generators) {
+      try {
+        await factory2.watch?.(entries, event);
+      } catch (error) {
+        console.error(
+          styleText("red", `${sourceFolder.name}: ${name} generator failed`)
+        );
+        if (event) {
+          console.error(event);
+        }
+        console.error(error);
+      }
+    }
+  };
+  const updateResolvedEntry = async (file) => {
+    const resolver = resolvers.get(file);
+    if (!resolver) {
+      return;
+    }
+    try {
+      const resolvedEntry = await resolver.handler(file);
+      resolvedRoutes.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
+      return resolvedEntry;
+    } catch (error) {
+      const route = file.replace(`${createPath.api()}/`, "");
+      console.error(
+        styleText(
+          "red",
+          `${sourceFolder.name}: ${route} route resolution failed`
+        )
+      );
+      console.error(error);
+      return;
+    }
+  };
+  {
+    const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
+    for (const { name, handler } of resolvers.values()) {
+      spinner.append(
+        `[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`
+      );
+      const route = await handler();
+      resolvedRoutes.set(route.entry.fileFullpath, route);
+    }
+    spinner.succeed("ready \u2728");
+  }
+  await runGenerators();
+  return {
+    async add(file) {
+      const [resolver] = resolversFactory([file]).values();
+      if (!resolver) {
+        return;
+      }
+      resolvers.set(file, resolver);
+      const resolvedEntry = await updateResolvedEntry(file);
+      if (resolvedEntry) {
+        await runGenerators({ kind: "create", file });
+      }
+    },
+    async change(file) {
+      if (resolvedRoutes.has(file)) {
+        await updateResolvedEntry(file);
+      } else {
+        const relatedRoutes = resolvedRoutes.values().flatMap(({ kind, entry }) => {
+          return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
+        });
+        for (const route of relatedRoutes) {
+          await updateResolvedEntry(route.fileFullpath);
+        }
+      }
+      await runGenerators({ kind: "update", file });
+    },
+    async unlink(file) {
+      resolvers.delete(file);
+      resolvedRoutes.delete(file);
+      await runGenerators({ kind: "delete", file });
+    }
+  };
+};
+var matchersFactory = ({
+  baseurl,
+  apiurl
+}) => {
+  const basePattern = new RegExp(`^${baseurl}($|/*)`);
+  const apiPattern = new RegExp(`^${join(baseurl, apiurl)}($|/*)`);
+  return {
+    base(req) {
+      return apiPattern.test(req.url) ? false : basePattern.test(req.url);
+    },
+    api(req) {
+      return apiPattern.test(req.url);
+    }
+  };
+};
+var findFreePort = async (devPort) => {
+  let minPort = 0;
+  let maxPort = 0;
+  for (const n of [3, 2, 1, ""]) {
+    minPort = Number(`${n}${devPort}`) + 100;
+    maxPort = minPort + 100;
+    if (maxPort < 65e3) {
+      break;
+    }
+  }
+  if (maxPort >= 65e3) {
+    throw new Error("the devPort in package.json should be less than 64000");
+  }
+  const range = maxPort - minPort + 1;
+  const startOffset = Math.floor(Math.random() * range);
+  const ports = Array.from({ length: range }, (_, i) => {
+    return minPort + (startOffset + i) % range;
+  });
+  const freePort = await ports.reduce(
+    async (prevPromise, port) => {
+      const freePort2 = await prevPromise;
+      if (freePort2) {
+        return freePort2;
+      }
+      const isFree = await isPortFree(port);
+      return isFree ? port : void 0;
+    },
+    Promise.resolve(void 0)
+  );
+  if (!freePort) {
+    throw new Error(`No free ports found in range ${minPort}-${maxPort}`);
+  }
+  return freePort;
+};
+var isPortFree = (port) => {
+  return new Promise((resolve3) => {
+    const server = net.createServer();
+    server.once("error", () => resolve3(false));
+    server.once("listening", () => {
+      server.close();
+      resolve3(true);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+};
+export {
+  chassis_default as default
+};
+//# sourceMappingURL=chassis.js.map