@storm-software/cloudflare-tools 0.48.0 → 0.49.1

package/dist/chunk-VPT6GF3S.mjs

@@ -0,0 +1,153 @@
+import {
+  getInternalDependencies,
+  r2UploadFile
+} from "./chunk-VYOULWAK.mjs";
+import {
+  createCliOptions,
+  getPackageInfo
+} from "./chunk-XU6MTFCV.mjs";
+import {
+  loadStormConfig
+} from "./chunk-OARYMVO7.mjs";
+import {
+  findWorkspaceRoot,
+  writeDebug,
+  writeInfo,
+  writeSuccess,
+  writeWarning
+} from "./chunk-NSLK6ZDO.mjs";
+import {
+  __name
+} from "./chunk-A7FFSBE6.mjs";
+
+// src/executors/r2-upload-publish/executor.ts
+import { S3 } from "@aws-sdk/client-s3";
+import { joinPathFragments, readCachedProjectGraph } from "@nx/devkit";
+import { glob } from "glob";
+import { execSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+async function runExecutor(options, context) {
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+  console.info(`\u{1F680}  Running Storm Cloudflare Publish executor on the ${context.projectName} worker`);
+  if (!context.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
+    throw new Error("The executor requires projectsConfigurations.");
+  }
+  try {
+    const workspaceRoot = findWorkspaceRoot();
+    const config = await loadStormConfig(workspaceRoot);
+    const sourceRoot = context.projectsConfigurations.projects[context.projectName]?.sourceRoot ?? workspaceRoot;
+    const projectName = context.projectsConfigurations.projects[context.projectName]?.name ?? context.projectName;
+    const projectDetails = getPackageInfo(context.projectsConfigurations.projects[context.projectName]);
+    if (!projectDetails?.content) {
+      throw new Error(`Could not find the project details for ${context.projectName}`);
+    }
+    const args = createCliOptions({
+      ...options
+    });
+    if (isDryRun) {
+      args.push("--dry-run");
+    }
+    const cloudflareAccountId = process.env.STORM_BOT_CLOUDFLARE_ACCOUNT;
+    if (!options?.registry && !cloudflareAccountId) {
+      throw new Error("The Storm Registry URL is not set in the Storm config. Please set either the `extensions.cyclone.registry` or `config.extensions.cyclone.accountId` property in the Storm config.");
+    }
+    if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+      throw new Error("The AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are not set. Please set these environment variables to upload to the Cyclone Registry.");
+    }
+    const endpoint = options?.registry ? options.registry : `https://${cloudflareAccountId}.r2.cloudflarestorage.com`;
+    const projectGraph = readCachedProjectGraph();
+    if (!projectGraph) {
+      throw new Error("No project graph found in cache");
+    }
+    writeInfo(`Publishing ${context.projectName} to the Storm Registry at ${endpoint}`);
+    const s3Client = new S3({
+      region: "auto",
+      endpoint,
+      credentials: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+      }
+    });
+    const version = projectDetails.content?.version;
+    writeInfo(`Generated component version: ${version}`);
+    const files = await glob(joinPathFragments(sourceRoot, "**/*"), {
+      ignore: "**/{*.stories.tsx,*.stories.ts,*.spec.tsx,*.spec.ts}"
+    });
+    const projectPath = `registry/${context.projectName}`;
+    const internalDependencies = await getInternalDependencies(context.projectName, projectGraph);
+    const dependencies = internalDependencies.filter((projectNode) => !projectNode.data.tags || projectNode.data.tags.every((tag) => tag.toLowerCase() !== "component")).reduce((ret, dep) => {
+      if (!ret[dep.name]) {
+        ret[dep.name] = "latest";
+      }
+      return ret;
+    }, projectDetails.content.dependencies ?? {});
+    const release = options.tag ?? execSync("npm config get tag").toString().trim();
+    writeInfo(`Clearing out existing items in ${projectPath}`);
+    if (!isDryRun) {
+      const response = await s3Client.listObjects({
+        Bucket: options.bucketId,
+        Prefix: projectPath
+      });
+      if (response?.Contents && response.Contents.length > 0) {
+        writeDebug(`Deleting the following existing items from the component registry: ${response.Contents.map((item) => item.Key).join(", ")}`);
+        await Promise.all(response.Contents.map((item) => s3Client.deleteObjects({
+          Bucket: options.bucketId,
+          Delete: {
+            Objects: [
+              {
+                Key: item.Key
+              }
+            ],
+            Quiet: false
+          }
+        })));
+      } else {
+        writeDebug(`No existing items to delete in the component registry path ${projectPath}`);
+      }
+    } else {
+      writeWarning("[Dry run]: skipping upload to the Cyclone Registry.");
+    }
+    const meta = {
+      name: context.projectName,
+      version,
+      release,
+      description: projectDetails.content.description,
+      tags: projectDetails.content.keywords,
+      dependencies,
+      devDependencies: null,
+      internalDependencies: internalDependencies.filter((projectNode) => projectNode.data.tags && projectNode.data.tags.some((tag) => tag.toLowerCase() === "component")).map((dep) => dep.name)
+    };
+    if (projectDetails.type === "package.json") {
+      meta.devDependencies = projectDetails.content.devDependencies;
+    }
+    const metaJson = JSON.stringify(meta);
+    writeInfo(`Generating meta.json file: 
+${metaJson}`);
+    await r2UploadFile(s3Client, options.bucketId, projectPath, "meta.json", version, metaJson, "application/json", isDryRun);
+    await Promise.all(files.map((file) => {
+      const fileName = file.replaceAll("\\", "/").replace(sourceRoot.replaceAll("\\", "/"), "");
+      return readFile(file, {
+        encoding: "utf8"
+      }).then((fileContent) => r2UploadFile(s3Client, options.bucketId, projectPath, fileName, version, fileContent, "text/plain", isDryRun));
+    }));
+    writeSuccess(`Successfully uploaded the ${projectName} component to the Cyclone Registry`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error("Failed to publish to Cloudflare Workers Registry");
+    console.error(error);
+    console.log("");
+    return {
+      success: false
+    };
+  }
+}
+__name(runExecutor, "runExecutor");
+
+export {
+  runExecutor
+};

package/dist/chunk-VTHBMY4B.js

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJ5SB6L2Ljs = require('./chunk-J5SB6L2L.js');
+
+// ../workspace-tools/src/utils/create-cli-options.ts
+var _devkit = require('@nx/devkit');
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = _devkit.names.call(void 0, key).fileName;
+      if (Array.isArray(value)) {
+        args.push(`--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`);
+      } else {
+        args.push(`--${arg.toLowerCase()}=${value}`);
+      }
+    }
+  }
+  return args;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, createCliOptions, "createCliOptions");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+
+var _fs = require('fs');
+
+// ../workspace-tools/src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (variant, value) => {
+  return `${variant}:${value}`;
+}, "formatProjectTag");
+var hasProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
+}, "hasProjectTag");
+var getProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return _optionalChain([tag, 'optionalAccess', _ => _.replace, 'call', _2 => _2(prefix, "")]);
+}, "getProjectTag");
+var isEqualProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && _optionalChain([tag, 'optionalAccess', _3 => _3.toUpperCase, 'call', _4 => _4()]) === value.toUpperCase());
+}, "isEqualProjectTag");
+var addProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
+    project.tags.push(formatProjectTag(variant, value));
+  }
+}, "addProjectTag");
+
+// ../workspace-tools/src/utils/toml.ts
+var _jtoml = require('@ltd/j-toml'); var _jtoml2 = _interopRequireDefault(_jtoml);
+
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return _jtoml2.default.parse(cargoString, {
+    x: {
+      comment: true
+    }
+  });
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, parseCargoToml, "parseCargoToml");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+var getPackageInfo = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project) => {
+  if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(_devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.TYPESCRIPT) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: _devkit.readJsonFile.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))
+    };
+  }
+  return null;
+}, "getPackageInfo");
+
+
+
+
+
+
+exports.ProjectTagConstants = ProjectTagConstants; exports.addProjectTag = addProjectTag; exports.createCliOptions = createCliOptions; exports.getPackageInfo = getPackageInfo;

package/dist/chunk-VYOULWAK.mjs

@@ -0,0 +1,42 @@
+import {
+  writeDebug,
+  writeWarning
+} from "./chunk-NSLK6ZDO.mjs";
+import {
+  __name
+} from "./chunk-A7FFSBE6.mjs";
+
+// src/utils/r2-bucket-helpers.ts
+import { createHash } from "node:crypto";
+var r2UploadFile = /* @__PURE__ */ __name(async (client, bucketName, projectPath, fileName, version, fileContent, contentType = "text/plain", isDryRun = false) => {
+  const checksum = createHash("sha256").update(fileContent).digest("base64");
+  const fileKey = `${projectPath}/${fileName.startsWith("/") ? fileName.substring(1) : fileName}`;
+  writeDebug(`Uploading file: ${fileKey}`);
+  if (!isDryRun) {
+    await client.putObject({
+      Bucket: bucketName,
+      Key: fileKey,
+      Body: fileContent.replaceAll(' from "@cyclone-ui/', ' from "../'),
+      ContentType: contentType,
+      Metadata: {
+        version,
+        checksum
+      }
+    });
+  } else {
+    writeWarning("[Dry run]: skipping upload to the Cyclone Registry.");
+  }
+}, "r2UploadFile");
+var getInternalDependencies = /* @__PURE__ */ __name((projectName, graph) => {
+  const allDeps = graph.dependencies[projectName] ?? [];
+  return Array.from(allDeps.reduce((acc, node) => {
+    const found = graph.nodes[node.target];
+    if (found) acc.push(found);
+    return acc;
+  }, []));
+}, "getInternalDependencies");
+
+export {
+  r2UploadFile,
+  getInternalDependencies
+};

package/dist/chunk-W5J5EWQN.js

@@ -0,0 +1,227 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkNPJPHEFPjs = require('./chunk-NPJPHEFP.js');
+
+
+var _chunkYE4FHRXJjs = require('./chunk-YE4FHRXJ.js');
+
+
+
+
+
+
+
+
+var _chunkRCE3CC76js = require('./chunk-RCE3CC76.js');
+
+
+var _chunkJ5SB6L2Ljs = require('./chunk-J5SB6L2L.js');
+
+// src/generators/worker/generator.ts
+var _devkit = require('@nx/devkit');
+var _projectnameandrootutils = require('@nx/devkit/src/generators/project-name-and-root-utils');
+var _node = require('@nx/node');
+var _versions = require('@nx/node/src/utils/versions');
+var _path = require('path');
+
+// src/generators/worker/libs/get-account-id.ts
+function getAccountId(accountId) {
+  return `account_id = "${accountId}"`;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, getAccountId, "getAccountId");
+
+// src/generators/worker/libs/vitest-imports.ts
+var vitestImports = `import { describe, expect, it, beforeAll, afterAll } from 'vitest';`;
+
+// src/generators/worker/libs/vitest-script.ts
+var vitestScript = `"test": "vitest run"`;
+
+// src/generators/worker/generator.ts
+async function applicationGenerator(tree, schema) {
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Storm Worker generator");
+  let config;
+  try {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u26A1 Running the Storm Worker generator...
+
+`, config);
+    const workspaceRoot = _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, );
+    _chunkRCE3CC76js.writeDebug.call(void 0, `Loading the Storm Config from environment variables and storm.json file...
+- workspaceRoot: ${workspaceRoot}`, config);
+    config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot);
+    _chunkRCE3CC76js.writeTrace.call(void 0, `Loaded Storm config into env: 
+${Object.keys(process.env).map((key) => ` - ${key}=${JSON.stringify(process.env[key])}`).join("\n")}`, config);
+    const options = await normalizeOptions(tree, schema, config);
+    const tasks = [];
+    tasks.push(await _chunkNPJPHEFPjs.generator_default.call(void 0, tree, {
+      ...options,
+      skipFormat: true
+    }));
+    tasks.push(await _node.applicationGenerator.call(void 0, tree, {
+      ...options,
+      framework: "none",
+      skipFormat: true,
+      unitTestRunner: options.unitTestRunner == "vitest" ? "none" : options.unitTestRunner,
+      e2eTestRunner: "none",
+      name: schema.name
+    }));
+    if (options.unitTestRunner === "vitest") {
+      const { vitestGenerator, createOrEditViteConfig } = _devkit.ensurePackage.call(void 0, "@nx/vite", _versions.nxVersion);
+      const vitestTask = await vitestGenerator(tree, {
+        project: options.name,
+        uiFramework: "none",
+        coverageProvider: "v8",
+        skipFormat: true,
+        testEnvironment: "node"
+      });
+      tasks.push(vitestTask);
+      createOrEditViteConfig(tree, {
+        project: options.name,
+        includeLib: false,
+        includeVitest: true,
+        testEnvironment: "node"
+      }, true);
+    }
+    addCloudflareFiles(tree, options);
+    updateTsAppConfig(tree, options);
+    addTargets(tree, options);
+    if (options.unitTestRunner === "none") {
+      removeTestFiles(tree, options);
+    }
+    if (!options.skipFormat) {
+      await _devkit.formatFiles.call(void 0, tree);
+    }
+    if (options.template === "hono") {
+      tasks.push(() => {
+        const packageJsonPath = _devkit.joinPathFragments.call(void 0, _nullishCoalesce(options.directory, () => ( "")), "package.json");
+        if (tree.exists(packageJsonPath)) {
+          _devkit.updateJson.call(void 0, tree, packageJsonPath, (json) => ({
+            ...json,
+            dependencies: {
+              hono: "4.4.0",
+              ..._optionalChain([json, 'optionalAccess', _ => _.dependencies])
+            }
+          }));
+        }
+      });
+    }
+    return _devkit.runTasksInSerial.call(void 0, ...tasks);
+  } catch (error) {
+    return () => {
+      _chunkRCE3CC76js.writeFatal.call(void 0, "A fatal error occurred while running the generator - the process was forced to terminate", config);
+      _chunkRCE3CC76js.writeError.call(void 0, `An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    };
+  } finally {
+    stopwatch();
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, applicationGenerator, "applicationGenerator");
+function updateTsAppConfig(tree, options) {
+  _devkit.updateJson.call(void 0, tree, _path.join.call(void 0, options.appProjectRoot, "tsconfig.app.json"), (json) => {
+    json.compilerOptions = {
+      ...json.compilerOptions,
+      esModuleInterop: true,
+      target: "es2021",
+      lib: [
+        "es2021"
+      ],
+      module: "es2022",
+      moduleResolution: "node",
+      resolveJsonModule: true,
+      allowJs: true,
+      checkJs: false,
+      noEmit: true,
+      isolatedModules: true,
+      allowSyntheticDefaultImports: true,
+      forceConsistentCasingInFileNames: true,
+      strict: true,
+      skipLibCheck: true
+    };
+    json.compilerOptions.types = [
+      ...json.compilerOptions.types,
+      "@cloudflare/workers-types"
+    ];
+    return json;
+  });
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, updateTsAppConfig, "updateTsAppConfig");
+function addCloudflareFiles(tree, options) {
+  tree.delete(_path.join.call(void 0, options.appProjectRoot, "src/main.ts"));
+  _devkit.generateFiles.call(void 0, tree, _path.join.call(void 0, __dirname, "./files/common"), options.appProjectRoot, {
+    ...options,
+    tmpl: "",
+    name: options.name,
+    accountId: options.accountId ? getAccountId(options.accountId) : "",
+    vitestScript: options.unitTestRunner === "vitest" ? vitestScript : ""
+  });
+  if (options.template && options.template !== "none") {
+    _devkit.generateFiles.call(void 0, tree, _path.join.call(void 0, __dirname, `./files/${options.template}`), _path.join.call(void 0, options.appProjectRoot, "src"), {
+      ...options,
+      tmpl: "",
+      name: options.name,
+      accountId: options.accountId ? getAccountId(options.accountId) : "",
+      vitestScript: options.unitTestRunner === "vitest" ? vitestScript : "",
+      vitestImports: options.unitTestRunner === "vitest" ? vitestImports : ""
+    });
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, addCloudflareFiles, "addCloudflareFiles");
+function addTargets(tree, options) {
+  try {
+    const projectConfiguration = _devkit.readProjectConfiguration.call(void 0, tree, options.name);
+    projectConfiguration.targets = {
+      ..._nullishCoalesce(projectConfiguration.targets, () => ( {})),
+      serve: {
+        executor: "@storm-software/cloudflare-tools:serve",
+        options: {
+          port: options.port
+        }
+      },
+      "nx-release-publish": {
+        executor: "@storm-software/cloudflare-tools:cloudflare-publish"
+      }
+    };
+    if (projectConfiguration.targets.build) {
+      delete projectConfiguration.targets.build;
+    }
+    _devkit.updateProjectConfiguration.call(void 0, tree, options.name, projectConfiguration);
+  } catch (e) {
+    console.error(e);
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, addTargets, "addTargets");
+function removeTestFiles(tree, options) {
+  tree.delete(_path.join.call(void 0, options.appProjectRoot, "src", "index.test.ts"));
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, removeTestFiles, "removeTestFiles");
+async function normalizeOptions(host, options, config) {
+  const { projectName: appProjectName, projectRoot: appProjectRoot } = await _projectnameandrootutils.determineProjectNameAndRootOptions.call(void 0, host, {
+    name: options.name,
+    projectType: "application",
+    directory: options.directory,
+    rootProject: options.rootProject
+  });
+  options.rootProject = appProjectRoot === ".";
+  return {
+    addPlugin: process.env.NX_ADD_PLUGINS !== "false",
+    accountId: process.env.STORM_BOT_CLOUDFLARE_ACCOUNT,
+    ...options,
+    name: _devkit.names.call(void 0, appProjectName).fileName,
+    frontendProject: options.frontendProject ? _devkit.names.call(void 0, options.frontendProject).fileName : void 0,
+    appProjectRoot,
+    unitTestRunner: _nullishCoalesce(options.unitTestRunner, () => ( "vitest")),
+    rootProject: _nullishCoalesce(options.rootProject, () => ( false)),
+    template: _nullishCoalesce(options.template, () => ( "fetch-handler")),
+    port: _nullishCoalesce(options.port, () => ( 3e3))
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, normalizeOptions, "normalizeOptions");
+var generator_default2 = applicationGenerator;
+var applicationSchematic = _devkit.convertNxGenerator.call(void 0, applicationGenerator);
+
+
+
+
+
+exports.applicationGenerator = applicationGenerator; exports.generator_default = generator_default2; exports.applicationSchematic = applicationSchematic;