@ohos-ports/nx-web 0.0.0-stage → 23.3.0-beta.0

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)](<>)
+[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+[![Hours saved](https://img.shields.io/endpoint?url=https%3A%2F%2Fstaging.nx.app%2Fnx-cloud%2Fbadge%2F62d013ea0852fe0a2df74438%2Fhours-saved.json)](https://nx.dev/nx-cloud)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Monorepos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+This package is a [Web plugin for Nx](https://nx.dev/nx-api/web).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://nx.dev/blog)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Monorepos · Fast Builds"></a></p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/dist/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2026 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/babel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/babel.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nxJsBabelPreset = require('@nx/js/babel');
+/** @deprecated Use `@nx/js/babel`. */
+module.exports = function (api, options = {}) {
+    console.warn('`@nx/web/babel` has been deprecated. Use `@nx/js/babel` instead in your .babelrc files.');
+    return nxJsBabelPreset(api, options);
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { webInitGenerator } from './src/generators/init/init';
+export { applicationGenerator } from './src/generators/application/application';
+export { webStaticServeGenerator } from './src/generators/static-serve/static-serve-configuration';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webStaticServeGenerator = exports.applicationGenerator = exports.webInitGenerator = void 0;
+var init_1 = require("./src/generators/init/init");
+Object.defineProperty(exports, "webInitGenerator", { enumerable: true, get: function () { return init_1.webInitGenerator; } });
+var application_1 = require("./src/generators/application/application");
+Object.defineProperty(exports, "applicationGenerator", { enumerable: true, get: function () { return application_1.applicationGenerator; } });
+var static_serve_configuration_1 = require("./src/generators/static-serve/static-serve-configuration");
+Object.defineProperty(exports, "webStaticServeGenerator", { enumerable: true, get: function () { return static_serve_configuration_1.webStaticServeGenerator; } });

package/dist/internal.d.ts

@@ -0,0 +1,2 @@
+export { waitForPortOpen } from './src/utils/wait-for-port-open';
+export { default as fileServerExecutor } from './src/executors/file-server/file-server.impl';

package/dist/internal.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileServerExecutor = exports.waitForPortOpen = void 0;
+const tslib_1 = require("tslib");
+// Curated internal API surface for other first-party Nx plugins (e.g. @nx/react,
+// @nx/angular, @nx/rspack, @nx/next, @nx/remix, @nx/module-federation). Prefer
+// this over deep `@nx/web/src/*` imports — those are not part of the public API.
+var wait_for_port_open_1 = require("./src/utils/wait-for-port-open");
+Object.defineProperty(exports, "waitForPortOpen", { enumerable: true, get: function () { return wait_for_port_open_1.waitForPortOpen; } });
+var file_server_impl_1 = require("./src/executors/file-server/file-server.impl");
+Object.defineProperty(exports, "fileServerExecutor", { enumerable: true, get: function () { return tslib_1.__importDefault(file_server_impl_1).default; } });

package/dist/src/executors/file-server/compat.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/src/executors/file-server/compat.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const devkit_1 = require("@ohos-ports/nx-devkit");
+const file_server_impl_1 = tslib_1.__importDefault(require("./file-server.impl"));
+exports.default = (0, devkit_1.convertNxExecutor)(file_server_impl_1.default);

package/dist/src/executors/file-server/file-server.impl.d.ts

@@ -0,0 +1,8 @@
+import { ExecutorContext } from '@ohos-ports/nx-devkit';
+import { Schema } from './schema';
+export default function fileServerExecutor(options: Schema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl: string;
+}, {
+    success: boolean;
+}, unknown>;

package/dist/src/executors/file-server/file-server.impl.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fileServerExecutor;
+const tslib_1 = require("tslib");
+const internal_1 = require("@ohos-ports/nx-devkit/internal");
+const child_process_1 = require("child_process");
+const pc = tslib_1.__importStar(require("picocolors"));
+const devkit_1 = require("@ohos-ports/nx-devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const internal_2 = require("@nx/js/internal");
+const detect_port_1 = tslib_1.__importDefault(require("detect-port"));
+function getHttpServerArgs(options) {
+    const { buildTarget, parallel, host, proxyUrl, ssl, sslCert, sslKey, proxyOptions, watch, spa, cacheSeconds, ...rest } = options;
+    const args = [`-c${options.cacheSeconds}`];
+    for (const [key, value] of Object.entries(rest)) {
+        if (typeof value === 'boolean' && value) {
+            args.push(`--${key}`);
+        }
+        else if (typeof value === 'string') {
+            args.push(`--${key}=${value}`);
+        }
+    }
+    if (host) {
+        args.push(`-a=${host}`);
+    }
+    if (ssl) {
+        args.push(`-S`);
+    }
+    if (sslCert) {
+        args.push(`-C=${sslCert}`);
+    }
+    if (sslKey) {
+        args.push(`-K=${sslKey}`);
+    }
+    if (proxyUrl) {
+        args.push(`-P=${proxyUrl}`);
+    }
+    if (proxyOptions) {
+        Object.keys(options.proxyOptions).forEach((key) => {
+            args.push(`--proxy-options.${key}=${options.proxyOptions[key]}`);
+        });
+    }
+    return args;
+}
+function getBuildTargetCommand(options, context) {
+    const target = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+    const cmd = ['nx', 'run'];
+    if (target.configuration) {
+        cmd.push(`${target.project}:${target.target}:${target.configuration}`);
+    }
+    else {
+        cmd.push(`${target.project}:${target.target}`);
+    }
+    if (options.parallel) {
+        cmd.push(`--parallel`);
+    }
+    if (options.maxParallel) {
+        cmd.push(`--maxParallel=${options.maxParallel}`);
+    }
+    return cmd;
+}
+function getBuildTargetOutputPath(options, context) {
+    if (options.staticFilePath) {
+        return options.staticFilePath;
+    }
+    let outputPath;
+    try {
+        const target = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+        const buildOptions = (0, devkit_1.readTargetOptions)(target, context);
+        if (buildOptions?.outputPath) {
+            outputPath = buildOptions.outputPath;
+        }
+        else {
+            const project = context.projectGraph.nodes[context.projectName];
+            const buildTarget = project.data.targets[target.target];
+            outputPath = buildTarget.outputs?.[0];
+            if (outputPath) {
+                outputPath = (0, internal_1.interpolate)(outputPath, {
+                    projectName: project.data.name,
+                    projectRoot: project.data.root,
+                });
+                outputPath = (0, internal_2.stripGlobToBaseDir)(outputPath);
+            }
+        }
+    }
+    catch (e) {
+        throw new Error(`Invalid buildTarget: ${options.buildTarget}`);
+    }
+    if (!outputPath) {
+        throw new Error(`Unable to get the outputPath from buildTarget ${options.buildTarget}. Make sure ${options.buildTarget} has an outputPath property or manually provide an staticFilePath property`);
+    }
+    return outputPath;
+}
+function createFileWatcher(project, changeHandler) {
+    return internal_1.daemonClient.registerFileWatcher({
+        watchProjects: project ? [project] : 'all',
+        includeGlobalWorkspaceFiles: true,
+        includeDependencies: true,
+    }, async (error, val) => {
+        if (error === 'reconnecting') {
+            // Silent - daemon restarts automatically on lockfile changes
+            return;
+        }
+        else if (error === 'reconnected') {
+            // Silent - reconnection succeeded
+            return;
+        }
+        else if (error === 'closed') {
+            throw new Error('Failed to reconnect to daemon after multiple attempts');
+        }
+        else if (error) {
+            throw new Error(`Watch error: ${error?.message ?? 'Unknown'}`);
+        }
+        else if (val?.changedFiles.length > 0) {
+            changeHandler();
+        }
+    });
+}
+async function* fileServerExecutor(options, context) {
+    if (!options.buildTarget && !options.staticFilePath) {
+        throw new Error("You must set either 'buildTarget' or 'staticFilePath'.");
+    }
+    if (options.watch && !options.buildTarget) {
+        throw new Error("Watch error: You can only specify 'watch' when 'buildTarget' is set.");
+    }
+    let running = false;
+    let disposeWatch;
+    if (options.buildTarget) {
+        // Run the build target through the workspace package manager so workspaces
+        // that pin a non-npm manager (e.g. devEngines.packageManager) don't fail.
+        const pmc = (0, devkit_1.getPackageManagerCommand)();
+        const run = () => {
+            if (!running) {
+                running = true;
+                /**
+                 * Expose a variable to the build target to know if it's being run by the serve-static executor
+                 * This is useful because a config might need to change if it's being run by serve-static without the user's input
+                 * or if being ran by another executor (eg. E2E tests)
+                 * */
+                process.env.NX_SERVE_STATIC_BUILD_RUNNING = 'true';
+                try {
+                    const args = getBuildTargetCommand(options, context);
+                    (0, child_process_1.execFileSync)(pmc.exec, args, {
+                        stdio: [0, 1, 2],
+                        shell: true,
+                        windowsHide: true,
+                    });
+                }
+                catch {
+                    throw new Error(`Build target failed: ${pc.bold(options.buildTarget)}`);
+                }
+                finally {
+                    process.env.NX_SERVE_STATIC_BUILD_RUNNING = undefined;
+                    running = false;
+                }
+            }
+        };
+        if (!internal_1.daemonClient.enabled() && options.watch) {
+            devkit_1.output.warn({
+                title: 'Nx Daemon is not enabled. Static server is not watching for changes.',
+            });
+        }
+        if (internal_1.daemonClient.enabled() && options.watch) {
+            disposeWatch = await createFileWatcher(context.projectName, run);
+        }
+        // perform initial run
+        run();
+    }
+    const port = await (0, detect_port_1.default)(options.port || 8080);
+    const outputPath = getBuildTargetOutputPath(options, context);
+    if (options.spa) {
+        const src = (0, path_1.join)(outputPath, 'index.html');
+        const dst = (0, path_1.join)(outputPath, '404.html');
+        // See: https://github.com/http-party/http-server#magic-files
+        (0, fs_1.copyFileSync)(src, dst);
+        // We also need to ensure the proxyUrl is set, otherwise the browser will continue to throw a 404 error
+        // This can cause unexpected behaviors and failures especially in automated test suites
+        options.proxyUrl ??= `http${options.ssl ? 's' : ''}://localhost:${port}?`;
+    }
+    const args = getHttpServerArgs(options);
+    const { path: pathToHttpServerPkgJson, packageJson } = (0, internal_1.readModulePackageJson)('http-server', module.paths);
+    const pathToHttpServerBin = packageJson.bin['http-server'];
+    const pathToHttpServer = (0, path_1.resolve)(pathToHttpServerPkgJson.replace('package.json', ''), pathToHttpServerBin);
+    // detect port as close to when used to prevent port being used by another process
+    // when running in  parallel
+    args.push(`-p=${port}`);
+    const serve = (0, child_process_1.fork)(pathToHttpServer, [outputPath, ...args], {
+        stdio: 'pipe',
+        cwd: context.root,
+        env: {
+            FORCE_COLOR: 'true',
+            ...process.env,
+        },
+    });
+    const processExitListener = () => {
+        serve.kill();
+        if (disposeWatch) {
+            disposeWatch();
+        }
+        if (options.spa) {
+            (0, fs_1.unlinkSync)((0, path_1.join)(outputPath, '404.html'));
+        }
+    };
+    process.on('exit', processExitListener);
+    process.on('SIGTERM', processExitListener);
+    serve.stdout.on('data', (chunk) => {
+        if (chunk.toString().indexOf('GET') === -1) {
+            process.stdout.write(chunk);
+        }
+    });
+    serve.stderr.on('data', (chunk) => {
+        process.stderr.write(chunk);
+    });
+    yield {
+        success: true,
+        baseUrl: `${options.ssl ? 'https' : 'http'}://${options.host}:${port}`,
+    };
+    return new Promise((res) => {
+        serve.on('exit', (code, signal) => {
+            if (code === null)
+                code = (0, internal_1.signalToCode)(signal);
+            if (code == 0) {
+                res({ success: true });
+            }
+            else {
+                res({ success: false });
+            }
+        });
+    });
+}

package/dist/src/executors/file-server/schema.d.ts

@@ -0,0 +1,20 @@
+export interface Schema {
+  host?: string;
+  port?: number;
+  ssl?: boolean;
+  sslKey?: string;
+  sslCert?: string;
+  proxyUrl?: string;
+  buildTarget?: string;
+  parallel: boolean;
+  maxParallel?: number;
+  withDeps: boolean;
+  proxyOptions?: object;
+  watch?: boolean;
+  spa: boolean;
+  staticFilePath?: string;
+  cors?: boolean;
+  gzip?: boolean;
+  brotli?: boolean;
+  cacheSeconds?: number;
+}

package/dist/src/executors/file-server/schema.json

@@ -0,0 +1,107 @@
+{
+  "version": 2,
+  "continuous": true,
+  "outputCapture": "direct-nodejs",
+  "title": "File Server",
+  "description": "Serve a web application from a folder. This executor is a wrapper around the [http-server](https://www.npmjs.com/package/http-server) package.",
+  "type": "object",
+  "cli": "nx",
+  "properties": {
+    "buildTarget": {
+      "type": "string",
+      "description": "Target which builds the application."
+    },
+    "parallel": {
+      "type": "boolean",
+      "description": "Build the target in parallel.",
+      "default": true
+    },
+    "maxParallel": {
+      "type": "number",
+      "description": "Max number of parallel jobs."
+    },
+    "port": {
+      "type": "number",
+      "description": "Port to listen on.",
+      "default": 4200
+    },
+    "host": {
+      "type": "string",
+      "description": "Host to listen on.",
+      "default": "localhost"
+    },
+    "ssl": {
+      "type": "boolean",
+      "description": "Serve using `HTTPS`.",
+      "default": false
+    },
+    "sslKey": {
+      "type": "string",
+      "description": "SSL key to use for serving `HTTPS`."
+    },
+    "sslCert": {
+      "type": "string",
+      "description": "SSL certificate to use for serving `HTTPS`."
+    },
+    "proxyUrl": {
+      "type": "string",
+      "description": "URL to proxy unhandled requests to. _Note: If the 'spa' flag is set to true, manually setting this value will override the catch-all redirect functionality from http-server which may lead to unexpected behavior._"
+    },
+    "proxyOptions": {
+      "type": "object",
+      "description": "Options for the proxy used by `http-server`.",
+      "default": {},
+      "properties": {
+        "secure": {
+          "type": "boolean",
+          "default": false
+        }
+      },
+      "additionalProperties": true
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Watch for file changes.",
+      "default": true
+    },
+    "spa": {
+      "type": "boolean",
+      "description": "Redirect 404 errors to index.html (useful for SPA's)",
+      "default": false,
+      "x-priority": "important"
+    },
+    "staticFilePath": {
+      "type": "string",
+      "description": "Path where the build artifacts are located. If not provided then it will be infered from the buildTarget executor options as outputPath"
+    },
+    "cors": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "description": "Enable CORS",
+      "default": true
+    },
+    "gzip": {
+      "type": "boolean",
+      "description": "Enable gzip compression",
+      "default": false
+    },
+    "brotli": {
+      "type": "boolean",
+      "description": "Enable brotli compression",
+      "default": false
+    },
+    "cacheSeconds": {
+      "type": "number",
+      "description": "Set cache time (in seconds) for cache-control max-age header. To disable caching, use -1. Caching defaults to disabled.",
+      "default": -1
+    }
+  },
+  "additionalProperties": true,
+  "examplesFile": "../../../docs/file-server-examples.md"
+}

package/dist/src/generators/application/application.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@ohos-ports/nx-devkit';
+import { Schema } from './schema';
+export declare function applicationGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function applicationGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default applicationGenerator;