@impactor/nx-manager 2.0.2 → 2.0.4

package/index.d.ts

@@ -0,0 +1,11 @@
+export { default as ngBuilder } from './src/executors/universal-builder/builders/angular.js';
+export { default as esBuilder } from './src/executors/universal-builder/builders/esbuild.js';
+export { default as nestBuilder } from './src/executors/universal-builder/builders/nest.js';
+export * from './src/executors/universal-builder/post-build.js';
+export * from './src/executors/universal-builder/types/builder.js';
+export * from './src/executors/universal-builder/types/builder-options.js';
+export * from './src/executors/universal-builder/types/package.js';
+export * from './src/executors/universal-builder/universal-builder.js';
+export * from './src/executors/universal-builder/utils/detect-project-type.js';
+export * from './src/executors/universal-builder/utils/exec.js';
+export * from './src/executors/universal-builder/utils/get-tsconfig-file.js';

package/index.js

@@ -0,0 +1,16 @@
+import { default as default2 } from "./src/executors/universal-builder/builders/angular.js";
+import { default as default3 } from "./src/executors/universal-builder/builders/esbuild.js";
+import { default as default4 } from "./src/executors/universal-builder/builders/nest.js";
+export * from "./src/executors/universal-builder/post-build.js";
+export * from "./src/executors/universal-builder/types/builder.js";
+export * from "./src/executors/universal-builder/types/builder-options.js";
+export * from "./src/executors/universal-builder/types/package.js";
+export * from "./src/executors/universal-builder/universal-builder.js";
+export * from "./src/executors/universal-builder/utils/detect-project-type.js";
+export * from "./src/executors/universal-builder/utils/exec.js";
+export * from "./src/executors/universal-builder/utils/get-tsconfig-file.js";
+export {
+  default3 as esBuilder,
+  default4 as nestBuilder,
+  default2 as ngBuilder
+};

package/nx.json

@@ -0,0 +1,174 @@
+{
+  "$schema": "./node_modules/nx/schemas/nx-schema.json",
+  "targetDefaults": {
+    "build": {
+      "executor": "@impactor/nx-manager:universal-builder",
+      "dependsOn": ["typecheck", "prebuild", "^build"],
+      "cache": true,
+      "inputs": ["default", "^default"],
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "forceRnDefaultPostBuild": true
+      }
+    },
+    "serve": {
+      "executor": "nx:run-commands",
+      "dependsOn": ["build", "preserve"],
+      "continuous": true,
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "NODE_ENV=development pnpm tsx --env-file-if-exists=.env --env-file-if-exists=.env.local dist/main.js"
+      },
+      "configurations": {
+        "production": {
+          "command": "NODE_ENV=production pnpm tsx --env-file-if-exists=.env --env-file-if-exists=.env.local --env-file-if-exists=.env.production --env-file-if-exists=.env.production.local dist/main.js"
+        }
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "{projectRoot}/dist"
+      }
+    },
+    "test": {
+      "inputs": ["test"],
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "dependsOn": ["^build", "pretest"],
+      "configurations": {
+        "unit": {
+          "args": [
+            "--testPathIgnorePatterns '.*\\.e2e\\.spec\\.ts$'",
+            "--testPathIgnorePatterns '/.*-e2e/'",
+            "--testPathIgnorePatterns '/.*-e2e/'"
+          ]
+        },
+        "e2e": {
+          "args": [
+            "--testMatch '**/*-e2e/**/*.{spec,test}.[mc]?[jt]s?(x)'",
+            "--testMatch '**/e2e/**/*.{spec,test}.[mc]?[jt]s?(x)'",
+            "--testMatch  '**/*.e2e.(spec|test).?([mc])[jt]s?(x)'"
+          ]
+        }
+      }
+    },
+    "@angular/build:application": {
+      "cache": true,
+      "dependsOn": ["prebuild", "^build"],
+      "inputs": ["default", "^default"]
+    },
+    "@nx/angular:package": {
+      "cache": true,
+      "dependsOn": ["^build"],
+      "inputs": ["default", "^default"],
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "project": "{projectRoot}/ng-package.json",
+        "tsConfig": "{projectRoot}/tsconfig.lib.json"
+      }
+    },
+    "@nx/js:tsc": {
+      "cache": true,
+      "dependsOn": ["^build"],
+      "inputs": ["default", "^default"]
+    }
+  },
+  "namedInputs": {
+    "default": [
+      "{projectRoot}/src/**/*",
+      "!{projectRoot}/**/*.(spec|test)(.e2e)?.[tj]sx?",
+      "!{projectRoot}/**/e2e/**/*",
+      "{projectRoot}/.env(.*)?",
+      "{workspaceRoot}/tasks/(post-)?build.ts",
+      "{projectRoot}/(project|package|tsconfig)(.+)?.json",
+      "{workspaceRoot}/tsconfig.base.json",
+      {
+        "runtime": "node --version"
+      },
+      {
+        "env": "NODE_ENV"
+      }
+    ],
+    "test": [
+      "default",
+      "{projectRoot}/tsconfig.spec.json",
+      "{projectRoot}/jest.config.[jt]s",
+      "{workspaceRoot}/jest.config.[jt]s",
+      "{projectRoot}/**/*.(spec|test)(.e2e)?.[jt]sx?",
+      "{projectRoot}/**/e2e/**/*.[jt]sx?",
+      {
+        "externalDependencies": ["jest"]
+      }
+    ]
+  },
+  "plugins": [
+    {
+      "plugin": "@nx/js/typescript",
+      "options": {
+        "typecheck": {
+          "targetName": "typecheck"
+        },
+        "build": false
+      }
+    },
+    {
+      "plugin": "@nx/jest/plugin",
+      "options": {
+        "targetName": "test",
+        "ciTargetName": "test-ci"
+      }
+    }
+  ],
+  "tasksRunnerOptions": {
+    "default": {
+      "options": {
+        "useDaemonProcess": false
+      }
+    }
+  },
+  "generators": {
+    "@nx/angular:library": {
+      "linter": "eslint",
+      "unitTestRunner": "jest"
+    },
+    "@nx/angular:component": {
+      "style": "scss"
+    }
+  },
+  "release": {
+    "groups": {
+      "libs": {
+        "projects": ["libs/*"]
+      },
+      "apps": {
+        "projects": ["apps/*"],
+        "changelog": {
+          "projectChangelogs": {
+            "createRelease": "github"
+          }
+        }
+      }
+    },
+    "projectsRelationship": "independent",
+    "version": {
+      "conventionalCommits": true,
+      "updateDependents": "always",
+      "preVersionCommand": "pnpm nx run-many -t build",
+      "manifestRootsToUpdate": [
+        "{projectRoot}",
+        {
+          "path": "{projectRoot}/dist",
+          "preserveLocalDependencyProtocols": false
+        }
+      ]
+    },
+    "releaseTag": {
+      "pattern": "{projectName}@{version}"
+    },
+    "changelog": {
+      "projectChangelogs": true
+    }
+  },
+  "sync": {
+    "applyChanges": false
+  }
+}

package/package.json

@@ -1,40 +1,43 @@
 {
   "name": "@impactor/nx-manager",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "NX generators and executors",
   "type": "module",
   "private": false,
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "linkDirectory": false
   },
   "nx": {
     "projectType": "library",
     "targets": {
-      "build": {},
-      "semantic-release": {}
+      "build": {}
     }
   },
+  "imports": {
+    "#*": "./src/*"
+  },
   "exports": {
     ".": {
       "types": "./index.d.js",
       "default": "./index.js"
     },
+    "./*": {
+      "types": "./src/*",
+      "default": "./src/*"
+    },
     "./package.json": {
       "default": "./package.json"
     },
-    "./*": "./src/*"
+    "./executors.json": "./executors.json"
   },
-  "files": [
-    "dist",
-    "!**/*.tsbuildinfo",
-    "executors.json"
-  ],
+  "types": "./index.d.ts",
+  "main": "./index.js",
   "dependencies": {
     "@nx/angular": "22.3.3",
-    "@nx/devkit": "22.3.3",
-    "@nx/esbuild": "22.3.3",
-    "tslib": "^2.8.1",
-    "@impactor/nodejs": "3.0.2"
+    "@nx/devkit": "22.4.5",
+    "@nx/esbuild": "22.4.5",
+    "tslib": "^2.8.1"
   },
   "executors": "./executors.json",
   "devDependencies": {

package/src/executors/universal-builder/builders/angular.d.ts

@@ -0,0 +1,16 @@
+import { type ExecutorContext } from '@nx/devkit';
+import type { IBuildAngularAppOptions, IBuildAngularLibraryOptions, IBuildAngularNormalizedOptions, IBuildAngularOptions } from '../types/builder-options.js';
+export default function build(options: IBuildAngularOptions, ctx: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function buildAngularLibrary(options: IBuildAngularNormalizedOptions, ctx: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function buildAngularApp(options: IBuildAngularNormalizedOptions, ctx: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function getOptions(options: IBuildAngularOptions, _ctx: ExecutorContext): Promise<IBuildAngularNormalizedOptions>;
+export declare function getLibraryOptions(options: IBuildAngularNormalizedOptions, _ctx: ExecutorContext): IBuildAngularLibraryOptions;
+export declare function getAppOptions(options: IBuildAngularNormalizedOptions, _ctx: ExecutorContext): IBuildAngularAppOptions & {
+    tsConfig: string;
+};

package/src/executors/universal-builder/builders/angular.js

@@ -0,0 +1,123 @@
+import { packageExecutor } from "@nx/angular/src/executors/package/package.impl";
+import applicationExecutor from "@nx/angular/src/executors/application/application.impl";
+import { getTsConfigFile } from "../utils/get-tsconfig-file";
+import { relative } from "node:path";
+import { readJSON } from "../utils/fs";
+async function build(options, ctx) {
+  let opts = await getOptions(options, ctx);
+  if (opts.projectType === "library") return buildAngularLibrary(opts, ctx);
+  if (opts.projectType === "application") return buildAngularApp(opts, ctx);
+  return { success: false };
+}
+async function buildAngularLibrary(options, ctx) {
+  let opts = getLibraryOptions(options, ctx);
+  let results = await packageExecutor(opts, ctx);
+  for await (let result of results) {
+    if (!result.success) return { success: false };
+  }
+  return { success: true };
+}
+async function buildAngularApp(options, ctx) {
+  let opts = getAppOptions(options, ctx);
+  if (opts.outputMode) {
+    console.warn(
+      `The option outputMode is currently not supported, it will be ignored`
+    );
+    delete opts.outputMode;
+  }
+  if (opts.ssr && typeof opts.ssr !== "boolean") {
+    console.warn(
+      `The option ssr curently support boolean values only, it'll considered as true`
+    );
+    opts.ssr = true;
+  }
+  let results = await applicationExecutor(opts, ctx);
+  for await (let result of results) {
+    if (!result.success) return { success: false };
+  }
+  return { success: true };
+}
+async function getOptions(options, _ctx) {
+  let opts = { ...options };
+  if (!opts.angularConfigs) {
+    opts.angularConfigs = readJSON(
+      `${opts.projectPath}/angular.json`
+    );
+  }
+  opts.projectType = opts.projectType || opts.projectConfig.projectType || // todo: remove the scope part from the projectName i.e. @scope/name -> name
+  // @ts-ignore
+  opts.angularConfigs?.projects?.[opts.projectName]?.projectType;
+  if (!opts.projectType) {
+    throw new Error(`projectType is not provided`);
+  }
+  if (!["library", "application"].includes(opts.projectType)) {
+    throw new Error(
+      `projectType ${opts.projectType} is not supported. supported values are "library","application"`
+    );
+  }
+  let tsConfig = (
+    // todo: remove `./`
+    opts.tsConfig || opts.angularConfigs?.projects?.[opts.projectName]?.tsConfig || getTsConfigFile(opts)
+  );
+  let relativeProjectPath = relative(opts.root, opts.projectPath);
+  opts.tsConfig = `${relativeProjectPath}/${tsConfig}`;
+  let buildOptions = (
+    // @ts-ignore
+    opts.angularConfigs?.projects?.[opts.projectName]?.architect?.build?.options
+  );
+  if (buildOptions) {
+    let properties = [
+      "root",
+      "sourceRoot",
+      "index",
+      "browser",
+      "assets",
+      "styles",
+      "scripts",
+      "server",
+      "serviceWorker",
+      "outputPath",
+      "tsConfig"
+      // 'serviceWorker',
+    ];
+    for (let prop of properties) {
+      if (typeof buildOptions[prop] === "string") {
+        buildOptions[prop] = `${relativeProjectPath}/${buildOptions[prop]}`;
+      } else if (Array.isArray(buildOptions[prop])) {
+        buildOptions[prop] = buildOptions[prop]?.map(
+          (el) => {
+            return typeof el === "string" ? `${relativeProjectPath}/${el}` : { ...el, input: `${relativeProjectPath}/${el.input}` };
+          }
+        );
+      }
+    }
+    if (buildOptions.ssr?.entry) {
+      buildOptions.ssr.entry = `${relativeProjectPath}/${buildOptions.ssr.entry}`;
+    }
+  }
+  opts = {
+    ...buildOptions,
+    ...opts
+  };
+  return opts;
+}
+function getLibraryOptions(options, _ctx) {
+  let opts = {
+    // todo: only if exists
+    project: `${options.projectPath}/ng-package.json`,
+    ...options
+  };
+  return opts;
+}
+function getAppOptions(options, _ctx) {
+  let opts = { ...options };
+  return opts;
+}
+export {
+  buildAngularApp,
+  buildAngularLibrary,
+  build as default,
+  getAppOptions,
+  getLibraryOptions,
+  getOptions
+};

package/src/executors/universal-builder/builders/esbuild.d.ts

@@ -0,0 +1,45 @@
+import { type EsBuildExecutorOptions } from '@nx/esbuild/src/executors/esbuild/schema.js';
+import { type IBuildEsbuildOptions } from '../types/builder-options.js';
+import { type ExecutorContext } from '@nx/devkit';
+export default function build(options: IBuildEsbuildOptions, ctx: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function getTargetOptions(opts: IBuildEsbuildOptions, ctx: ExecutorContext): Promise<{
+    tsConfig?: EsBuildExecutorOptions["tsConfig"];
+    esbuildConfigFile?: string;
+    esbuildOptions?: import("~~node_modules/esbuild/lib/main.js").BuildOptions;
+    builder: import("../types/builder.js").Builder;
+    projectName: string;
+    projectPath: string;
+    projectConfig: import("@nx/devkit").ProjectConfiguration;
+    flags: string[];
+    root: string;
+    outDir?: string;
+    postBuild?: boolean | string;
+    forceRnDefaultPostBuild?: true;
+    mode?: "development" | "production";
+    cwd?: string;
+    additionalEntryPoints?: string[] | undefined;
+    assets: (import("~~node_modules/@nx/js/src/utils/assets/assets.js").AssetGlob | string)[];
+    bundle?: boolean | undefined;
+    declaration?: boolean | undefined;
+    declarationRootDir?: string | undefined;
+    deleteOutputPath?: boolean | undefined;
+    esbuildConfig?: string | undefined;
+    external?: string[] | undefined;
+    excludeFromExternal?: string[] | undefined;
+    format?: Array<"esm" | "cjs"> | undefined;
+    generatePackageJson?: boolean | undefined;
+    main?: string | undefined;
+    metafile?: boolean | undefined;
+    minify?: boolean | undefined;
+    outputFileName?: string | undefined;
+    outputHashing?: "none" | "all" | undefined;
+    outputPath?: string | undefined;
+    platform?: "node" | "browser" | "neutral" | undefined;
+    sourcemap?: boolean | "linked" | "inline" | "external" | "both" | undefined;
+    skipTypeCheck?: boolean | undefined;
+    target?: string | undefined;
+    thirdParty?: boolean | undefined;
+    watch?: boolean | undefined;
+}>;

package/src/executors/universal-builder/builders/esbuild.js

@@ -0,0 +1,63 @@
+import { esbuildExecutor } from "@nx/esbuild/src/executors/esbuild/esbuild.impl.js";
+import { existsSync } from "node:fs";
+import { getTsConfigFile } from "../utils/get-tsconfig-file";
+async function build(options, ctx) {
+  let opts = await getTargetOptions(options, ctx);
+  ctx.target = ctx.target || {};
+  ctx.target.options.outputPath = opts.outputPath;
+  let results = esbuildExecutor(opts, ctx);
+  for await (let result of results) {
+    if (!result.success) return { success: false };
+  }
+  return { success: true };
+}
+async function getTargetOptions(opts, ctx) {
+  if (!opts.esbuildOptions && !opts.esbuildConfig) {
+    if (!opts.esbuildConfigFile) {
+      if (existsSync(`${opts.projectPath}/esbuild.config.ts`)) {
+        opts.esbuildConfigFile = `${opts.projectPath}/esbuild.config.ts`;
+      } else if (existsSync(`${ctx.root}/esbuild.config.ts`)) {
+        opts.esbuildConfigFile = `${ctx.root}/esbuild.config.ts`;
+      }
+    }
+    if (!opts.tsConfig) {
+      opts.tsConfig = `${getTsConfigFile(opts)}`;
+    }
+    if (opts.esbuildConfigFile) {
+      opts.esbuildOptions = await import(opts.esbuildConfigFile).then(
+        (m) => m.default({
+          projectRoot: opts.projectPath,
+          tsconfig: `${opts.projectPath}/${opts.tsConfig}`
+        })
+      );
+    }
+  }
+  if (!opts.outputPath) {
+    opts.outputPath = opts.esbuildOptions?.outdir || "dist";
+  }
+  if (!opts.main) {
+    if (Array.isArray(opts.esbuildOptions?.entryPoints) && opts.esbuildOptions.entryPoints.length > 0 && opts.esbuildOptions.entryPoints.every((el) => typeof el === "string")) {
+      [opts.main, ...opts.additionalEntryPoints] = opts.esbuildOptions.entryPoints;
+    } else if (existsSync(`${opts.projectPath}/index.ts`)) {
+      opts.main = `${opts.projectPath}/index.ts`;
+    } else if (existsSync(`${opts.projectPath}/src/index.ts`)) {
+      opts.main = `${opts.projectPath}/src/index.ts`;
+    } else {
+      throw new Error(
+        `[universal-builder] No entry point found for esbuild. specify options.esbuildOptions.entrypoint or create index.ts or src/index.ts in the project's root dir`
+      );
+    }
+  }
+  if (!opts.format) {
+    if (opts.esbuildOptions?.format && opts.esbuildOptions.format !== "iife") {
+      opts.format = [opts.esbuildOptions.format];
+    } else {
+      opts.format = ["esm"];
+    }
+  }
+  return { assets: [], ...opts };
+}
+export {
+  build as default,
+  getTargetOptions
+};

package/src/executors/universal-builder/builders/nest.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from '@nx/devkit';
+import type { IBuilderNestOptions } from '../types/builder-options.js';
+export default function build(options: IBuilderNestOptions, ctx: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function getOptions(options: IBuilderNestOptions, _ctx: ExecutorContext): IBuilderNestOptions;

package/src/executors/universal-builder/builders/nest.js

@@ -0,0 +1,54 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { exec } from "../utils/exec";
+async function build(options, ctx) {
+  let opts = getOptions(options, ctx);
+  let flags = ["@nestjs/cli", "build", ...opts.flags];
+  if (!flags.includes("--path") && !flags.includes("-p") && opts.tsConfig) {
+    flags.push("-p", opts.tsConfig);
+  }
+  if (opts.bundler) {
+    if (["tsc", "webpack"].includes(opts.bundler) && !flags.includes(`--${opts.bundler}`)) {
+      flags.push(`--${opts.bundler}`);
+    } else if (!flags.includes("--builder") && !flags.includes("-b")) {
+      flags.push("-b", opts.bundler);
+    }
+  }
+  if (!flags.includes("--config") && !flags.includes("-c") && opts.configFile) {
+    flags.push("-c", opts.configFile);
+  }
+  if (opts.typeCheck) {
+    flags.push("--type-check");
+  }
+  if (opts.watch && !flags.includes("--watch") && !flags.includes("-w")) {
+    flags.push("-w");
+  }
+  if (opts.watch && !flags.includes("--watchAssets")) {
+    flags.push("--watchAssets");
+  }
+  if (opts.webpackPath && !flags.includes("--webpackPath")) {
+    flags.push("--webpackPath", opts.webpackPath);
+  }
+  if (opts.webpackPath && !flags.includes("--preserveWatchOutput")) {
+    flags.push("--preserveWatchOutput", opts.webpackPath);
+  }
+  await exec("npx", flags, opts.projectPath);
+  return { success: true };
+}
+function getOptions(options, _ctx) {
+  let opts = { ...options };
+  if (!opts.bundler && !opts.flags.includes("--builder") && !opts.flags.includes("-b") && existsSync(resolve(`${opts.projectPath}/.swcrc`))) {
+    console.info(
+      `[universal-builder] SWC config file is detected, building using SWC`
+    );
+    opts.bundler = "swc";
+    if (!opts.configFile && !opts.flags.includes("--config") && !opts.flags.includes("-c")) {
+      opts.configFile = ".swcrc";
+    }
+  }
+  return opts;
+}
+export {
+  build as default,
+  getOptions
+};

package/src/executors/universal-builder/post-build.d.ts

@@ -0,0 +1,2 @@
+import { IBuilderBaseOptions } from './types/builder-options.js';
+export default function postBuild(options: IBuilderBaseOptions): void;

package/src/executors/universal-builder/post-build.js

@@ -0,0 +1,95 @@
+import { copyFileSync, existsSync, readdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { readJSON, writeJSON } from "./utils/fs";
+function postBuild(options) {
+  console.info(
+    `[universal-builder] running the default post-build script. to skip use options.postBuild=false`
+  );
+  let opts = {
+    ...options
+  };
+  let pkg = readJSON(`${opts.projectPath}/package.json`) || {}, distPkg = existsSync(`${opts.projectPath}/dist/package.json`) ? readJSON(`${opts.projectPath}/dist/package.json`) : pkg, rootPkg = readJSON(`${opts.root}/package.json`) || {}, dist = `${opts.projectPath}/${opts.outDir || "dist"}`;
+  if (!existsSync(dist)) {
+    throw new Error(
+      `[universal-builder] "${dist}" doesn't exist, be sure the app is built. if you're using a custom output dir, provide options.outDir`
+    );
+  }
+  for (let property of [
+    "engines",
+    "packageManager",
+    "repository",
+    "author",
+    "homepage",
+    "bugs",
+    "license",
+    "contributors",
+    "funding",
+    // `add pnpm.overrides` to override deps when installing in the server
+    "pnpm"
+  ]) {
+    if (!distPkg[property]) {
+      if (pkg[property]) distPkg[property] = pkg[property];
+      else if (rootPkg[property]) distPkg[property] = rootPkg[property];
+    }
+  }
+  if (!distPkg.exports) {
+    distPkg.exports = {};
+  }
+  if (!distPkg.exports["./package.json"]) {
+    distPkg.exports["./package.json"] = "./package.json";
+  }
+  if (distPkg.exports["."]) {
+    if (typeof distPkg.exports["."] === "string") {
+      distPkg.exports["."] = distPkg.exports["."].replace(/\.ts$/, ".js");
+    } else {
+      for (let key in distPkg.exports["."]) {
+        distPkg.exports["."][key] = distPkg.exports["."][key].replace(
+          /\.ts$/,
+          ".js"
+        );
+      }
+    }
+  } else {
+    distPkg.exports["."] = {
+      types: "./index.d.ts",
+      default: "./index.js"
+    };
+  }
+  if (!distPkg.exports["./*"]) {
+    distPkg.exports["./*"] = existsSync(`${dist}/src`) ? "./src/*" : "./*";
+  }
+  writeJSON(`${dist}/package.json`, distPkg);
+  ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"].map((el) => {
+    let path = resolve(`${opts.root}/${el}`);
+    if (existsSync(path)) {
+      copyFileSync(path, resolve(`${dist}/${el}`));
+    }
+  });
+  readdirSync(opts.projectPath).filter(
+    (el) => (
+      // matches `.env` and `.env.*`
+      /^\.env($|\..+)/.test(el)
+    )
+  ).map((el) => copyFileSync(`${opts.projectPath}/${el}`, `${dist}/${el}`));
+  ["README.md"].map((file) => {
+    if (existsSync(`${opts.projectPath}/${file}`)) {
+      copyFileSync(`${opts.projectPath}/${file}`, `${dist}/${file}`);
+    }
+  });
+  if (existsSync(`${opts.projectPath}/project.json`)) {
+    copyFileSync(`${opts.projectPath}/project.json`, `${dist}/project.json`);
+  }
+  if (existsSync(`${opts.root}/nx.json`)) {
+    copyFileSync(`${opts.root}/nx.json`, `${dist}/nx.json`);
+  }
+  if (!existsSync(`${dist}/main.js`)) {
+    if (existsSync(`${dist}/server/server.mjs`)) {
+      writeFileSync(`${dist}/main.js`, `import "./server/server.mjs"`);
+    } else if (existsSync(`${dist}/server/server.js`)) {
+      writeFileSync(`${dist}/main.js`, `import "./server/server.js"`);
+    }
+  }
+}
+export {
+  postBuild as default
+};

package/src/executors/universal-builder/types/builder-options.d.ts

@@ -0,0 +1,44 @@
+import { ProjectConfiguration } from 'nx/src/devkit-exports.js';
+import { UniversalBuilderExecutorSchema } from '../schema.js';
+import { type Builder } from './builder.js';
+import { type BuildOptions } from 'esbuild';
+import type { BuildAngularLibraryExecutorOptions } from '@nx/angular/src/executors/package/schema';
+import type { ApplicationExecutorOptions } from '@nx/angular/src/executors/application/schema';
+import type { EsBuildExecutorOptions } from '@nx/esbuild/src/executors/esbuild/schema.js';
+export type IBuilderOptions = IBuildEsbuildOptions | IBuildAngularOptions | IBuilderNestOptions;
+export interface IBuilderBaseOptions extends UniversalBuilderExecutorSchema {
+    builder: Builder;
+    projectName: string;
+    projectPath: string;
+    projectConfig: ProjectConfiguration;
+    flags: string[];
+    root: string;
+}
+export interface IBuildEsbuildOptions extends IBuilderBaseOptions, Partial<EsBuildExecutorOptions> {
+    tsConfig?: EsBuildExecutorOptions['tsConfig'];
+    esbuildConfigFile?: string;
+    esbuildOptions?: BuildOptions;
+}
+export interface IBuildAngularBaseOptions extends IBuilderBaseOptions {
+    projectType?: 'application' | 'library';
+    tsConfig?: string;
+    angularConfigs?: Record<string, unknown>;
+}
+export interface IBuildAngularLibraryOptions extends IBuildAngularBaseOptions, BuildAngularLibraryExecutorOptions {
+}
+export interface IBuildAngularAppOptions extends IBuildAngularBaseOptions, Omit<ApplicationExecutorOptions, 'tsConfig'> {
+}
+export type IBuildAngularOptions = IBuildAngularLibraryOptions | IBuildAngularAppOptions;
+export type IBuildAngularNormalizedOptions = IBuildAngularOptions & {
+    tsConfig: string;
+};
+export interface IBuilderNestOptions extends IBuilderBaseOptions {
+    bundler?: 'swc' | 'webpack' | 'tsc';
+    configFile?: string;
+    typeCheck?: boolean;
+    tsConfig?: string;
+    watch?: boolean;
+    watchAssets?: boolean;
+    webpackPath?: string;
+    preserveWatchOutput?: boolean;
+}

package/src/executors/universal-builder/types/builder.d.ts

@@ -0,0 +1 @@
+export type Builder = 'tsc' | 'esbuild' | 'webpack' | 'angular' | 'nest';

package/src/executors/universal-builder/types/package.d.ts

@@ -0,0 +1,64 @@
+export interface IPackage {
+    name?: string;
+    description?: string;
+    version?: string;
+    type?: 'module' | 'commonjs';
+    workspaces?: string[];
+    private?: boolean;
+    engines: {
+        node?: string;
+        [key: string]: unknown;
+    };
+    packageManager?: string;
+    scripts?: {
+        [key: string]: string;
+    };
+    imports?: {
+        [key: string]: string | {
+            [key: string]: string;
+        };
+    };
+    exports?: {
+        [key: string]: string | {
+            [key: string]: string;
+        };
+    };
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
+        [key: string]: string;
+    };
+    peerDependencies?: {
+        [key: string]: string;
+    };
+    optionalDependencies?: {
+        [key: string]: string;
+    };
+    keywords?: string[];
+    repository: string | {
+        type?: string;
+        url?: string;
+        [key: string]: unknown;
+    };
+    homepage?: string;
+    bugs: {
+        url?: string;
+        email?: string;
+    };
+    license?: string;
+    author?: string;
+    contributors?: string[];
+    funding?: [
+        {
+            type?: string;
+            url?: string;
+        }
+    ];
+    pnpm?: {
+        overrides?: {
+            [key: string]: string;
+        };
+    };
+    [key: string]: unknown;
+}

package/src/executors/universal-builder/universal-builder.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext, type PromiseExecutor } from '@nx/devkit';
+import type { UniversalBuilderExecutorSchema } from './schema.js';
+import type { IBuilderOptions } from './types/builder-options.js';
+declare const run: PromiseExecutor<UniversalBuilderExecutorSchema>;
+export default run;
+export declare function getOptions(options: UniversalBuilderExecutorSchema, ctx: ExecutorContext): IBuilderOptions;

package/src/executors/universal-builder/universal-builder.js

@@ -0,0 +1,119 @@
+import {
+  joinPathFragments
+} from "@nx/devkit";
+import {
+  detectProjectType
+} from "./utils/detect-project-type";
+import buildESBuild from "./builders/esbuild";
+import buildAngular from "./builders/angular";
+import buildNest from "./builders/nest";
+import { exec } from "./utils/exec";
+import { readFileSync } from "node:fs";
+const run = async (options, ctx) => {
+  let opts = getOptions(options, ctx);
+  console.info(`[universal-builder] building using builder: ${opts.builder}`);
+  let result;
+  let originalCwd = process.cwd();
+  if (opts.cwd && opts.cwd !== originalCwd) {
+    console.info(
+      `[universal-builder] changing CWD from ${originalCwd} to ${opts.cwd}`
+    );
+    process.chdir(opts.cwd);
+  }
+  if (opts.builder === "angular") {
+    result = await buildAngular(opts, ctx);
+  } else if (opts.builder === "nest") {
+    result = await buildNest(opts, ctx);
+  } else if (opts.builder === "esbuild") {
+    result = await buildESBuild(opts, ctx);
+  } else if (opts.builder === "webpack") {
+    throw new Error(
+      `[universal-builder] webpack builder has not implemented yet!`
+    );
+  } else {
+    throw new Error(
+      `[universal-builder] invalid or not supported builder ${opts.builder}`
+    );
+  }
+  if (!result.success) return result;
+  if (opts.postBuild) {
+    console.info(`[universal-builder] executing postbuild`, opts.postBuild);
+    if (Array.isArray(opts.postBuild)) {
+      await exec(opts.postBuild[0], opts.postBuild[1]);
+    } else {
+    }
+  } else if (options.postBuild !== false) {
+    if (opts.forceRnDefaultPostBuild) {
+      await import("./post-build").then((m) => m.default(opts));
+    }
+    console.info(
+      `[universal-builder] executing the script postbuild (if exists)`
+    );
+    let pkg = JSON.parse(
+      readFileSync(`${opts.projectPath}/package.json`, "utf8")
+    );
+    if (pkg.scripts?.postbuild) {
+      await exec(
+        // todo: detect the package manager (may be NX already provide it with opts)
+        "pnpm",
+        ["run", "postbuild"],
+        // the script should be executed from the project root even if opts.cwd is not specified
+        opts.projectPath
+      );
+    } else if (!opts.forceRnDefaultPostBuild) {
+      await import("./post-build").then((m) => m.default(opts));
+    }
+  }
+  if (opts.cwd && opts.cwd !== originalCwd) {
+    console.info(
+      `[universal-builder] resetting CWD from ${opts.cwd} to ${originalCwd}`
+    );
+    process.chdir(originalCwd);
+  }
+  console.info(
+    `[universal-builder] building ${opts.projectName} finished successfully`
+  );
+  return {
+    success: true
+  };
+};
+var universal_builder_default = run;
+function getOptions(options, ctx) {
+  let opts = {
+    projectName: ctx.projectName,
+    flags: [],
+    ...options
+  };
+  if (!opts.projectName) {
+    throw new Error("[universal-builder] projectName is not provided");
+  }
+  let projectConfig = ctx.projectsConfigurations?.projects[opts.projectName];
+  if (!projectConfig) {
+    throw new Error(
+      `[universal-builder] The project ${opts.projectName} is not existing`
+    );
+  }
+  if (!opts.projectPath) {
+    opts.projectPath = joinPathFragments(ctx.root, projectConfig.root);
+  }
+  if (!opts.projectPath) {
+    throw new Error("[universal-builder] projectPath is not provided");
+  }
+  if (!opts.builder) {
+    opts.builder = detectProjectType({
+      ...opts,
+      root: ctx.root
+    });
+  }
+  if (!opts.builder) {
+    throw new Error("[universal-builder] builder is not provided");
+  }
+  if (!opts.mode) {
+    opts.mode = process.env.NODE_MODE || ctx.configurationName || "production";
+  }
+  return { ...opts, root: ctx.root, projectConfig };
+}
+export {
+  universal_builder_default as default,
+  getOptions
+};

package/src/executors/universal-builder/universal-builder.spec.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "@jest/globals";
+import executor from "./universal-builder";
+const options = {};
+const context = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+  projectGraph: {
+    nodes: {},
+    dependencies: {}
+  },
+  projectsConfigurations: {
+    projects: {},
+    version: 2
+  },
+  nxJsonConfiguration: {}
+};
+describe("UniversalBuilder Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/universal-builder/utils/detect-project-type.d.ts

@@ -0,0 +1,7 @@
+import { Builder } from '../types/builder.js';
+export interface IDetectProjectTypeOptions {
+    projectPath: string;
+    projectName?: string;
+    root?: string;
+}
+export declare function detectProjectType(options: IDetectProjectTypeOptions): Builder;

package/src/executors/universal-builder/utils/detect-project-type.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+function detectProjectType(options) {
+  if (existsSync(`${options.projectPath}/nest-cli.json`)) {
+    return "nest";
+  } else if (existsSync(`${options.projectPath}/angular.json`)) {
+    return "angular";
+  } else if (["ng-", "ngx-"].some((prefix) => {
+    let pkgName = options.projectName?.match(/(?:@.+\/)?(.+)/)?.[1];
+    pkgName?.startsWith(prefix);
+  })) {
+    return "angular";
+  } else if (existsSync(`${options.projectPath}/esbuild.config.ts`) || existsSync(`${options.root}/esbuild.config.ts`)) {
+    return "esbuild";
+  } else if (existsSync(`${options.projectPath}/webpack.config.js`)) {
+    return "webpack";
+  } else if (existsSync(`${options.projectPath}/tsconfig.json`)) return "tsc";
+  else throw new Error(`cannot detect the project type`);
+}
+export {
+  detectProjectType
+};

package/src/executors/universal-builder/utils/exec.d.ts

@@ -0,0 +1 @@
+export declare function exec(cmd: string, args?: string[], cwd?: string): Promise<void>;

package/src/executors/universal-builder/utils/exec.js

@@ -0,0 +1,22 @@
+import { spawn } from "node:child_process";
+function exec(cmd, args = [], cwd) {
+  console.info(`[universal-builder] cwd: ${cwd || process.cwd()}`);
+  console.info(`[universal-builder] > ${cmd} ${args?.join(" ")}`);
+  return new Promise((res, rej) => {
+    let childProcess = spawn(cmd, args, {
+      shell: true,
+      cwd,
+      stdio: "inherit"
+    });
+    childProcess.on("error", (error) => {
+      rej(error);
+    });
+    childProcess.on("exit", (exitCode) => {
+      if (exitCode === 0) res();
+      else rej(`Process exited with code ${exitCode}`);
+    });
+  });
+}
+export {
+  exec
+};

package/src/executors/universal-builder/utils/fs.d.ts

@@ -0,0 +1,5 @@
+import { PathLike } from 'node:fs';
+export declare function readJSON<R extends Record<string, unknown>>(path: PathLike): R;
+export declare function writeJSON(path: PathLike, data: any): void;
+export declare function cleanJson(content: string): string;
+export declare function getEntriesSync(dir?: string | string[], filter?: ((entry: string) => boolean) | RegExp | 'files' | 'dirs', depth?: number, skip?: ((entry: string) => boolean) | RegExp): Array<string>;

package/src/executors/universal-builder/utils/fs.js

@@ -0,0 +1,92 @@
+import {
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function readJSON(path) {
+  path = resolve(path.toString());
+  let data = readFileSync(path, "utf8");
+  return JSON.parse(cleanJson(data));
+}
+function writeJSON(path, data) {
+  path = resolve(path.toString());
+  mkdirSync(dirname(path), { recursive: true });
+  let dataString = JSON.stringify(data, null, 2);
+  return writeFileSync(path, dataString);
+}
+function cleanJson(content) {
+  if (typeof content !== "string") {
+    throw new TypeError(`the content must be a string`);
+  }
+  let isInsideComment = false;
+  let isInsideString = false;
+  let offset = 0;
+  let result = "";
+  for (let index = 0; index < content.length; index++) {
+    let currentCharacter = content[index], chars = currentCharacter + content[index + 1];
+    if (isInsideComment) {
+      if (isInsideComment === "single" && chars === "\r\n" || isInsideComment === "multi" && chars === "*/") {
+        isInsideComment = false;
+        index++;
+        offset = ++index;
+      } else if (isInsideComment === "single" && ["\r", "\n"].includes(currentCharacter)) {
+        isInsideComment = false;
+        offset = ++index;
+      }
+    } else {
+      if (currentCharacter === '"' && !isEscaped(content, index)) {
+        isInsideString = !isInsideString;
+      }
+      if (isInsideString) continue;
+      else if (["//", "/*"].includes(chars)) {
+        isInsideComment = chars === "//" ? "single" : "multi";
+        result += content.slice(offset, index);
+        index++;
+      }
+    }
+  }
+  return result + content.slice(offset);
+}
+function isEscaped(content, charPosition) {
+  let index = charPosition - 1;
+  let backslashCount = 0;
+  while (content[index] === "\\") {
+    index--;
+    backslashCount++;
+  }
+  return Boolean(backslashCount % 2);
+}
+function getEntriesSync(dir = ".", filter, depth, skip) {
+  if (Array.isArray(dir)) {
+    return dir.flatMap((el) => getEntriesSync(el, filter, depth));
+  }
+  dir = resolve(dir);
+  let filterFunction = filter === "files" ? (entry) => lstatSync(entry).isFile() : filter === "dirs" ? (entry) => lstatSync(entry).isDirectory() : filter instanceof RegExp ? (entry) => filter.test(entry) : typeof filter === "function" ? filter : void 0;
+  let skipFunction = skip instanceof RegExp ? (entry) => skip.test(entry) : typeof skip === "function" ? skip : (entry) => ["node_modules", "dist"].includes(entry);
+  let entries = readdirSync(dir);
+  let result = [];
+  for (let entry of entries) {
+    let fullPath = join(dir, entry);
+    if (!filterFunction || filterFunction?.(fullPath)) {
+      result.push(fullPath);
+    }
+    if ((depth === void 0 || depth > 0) && lstatSync(fullPath).isDirectory() && !skipFunction?.(entry)) {
+      let subEntries = getEntriesSync(
+        fullPath,
+        filterFunction,
+        depth === void 0 ? void 0 : depth - 1
+      );
+      result = [...result, ...subEntries];
+    }
+  }
+  return result;
+}
+export {
+  cleanJson,
+  getEntriesSync,
+  readJSON,
+  writeJSON
+};

package/src/executors/universal-builder/utils/get-tsconfig-file.d.ts

@@ -0,0 +1,2 @@
+import { IBuilderOptions } from '../types/builder-options.js';
+export declare function getTsConfigFile(options: IBuilderOptions): string;

package/src/executors/universal-builder/utils/get-tsconfig-file.js

@@ -0,0 +1,12 @@
+import { existsSync } from "node:fs";
+function getTsConfigFile(options) {
+  if (options.tsConfig) return options.tsConfig;
+  let files = ["tsconfig.lib.json", "tsconfig.app.json", "tsconfig.json"];
+  for (let file of files) {
+    if (existsSync(`${options.projectPath}/${file}`)) return file;
+  }
+  throw new Error(`No tsconfig file is found in the project`);
+}
+export {
+  getTsConfigFile
+};