@ohos-ports/nx 17.3.2-beta.0

package/schemas/project-schema.json

@@ -0,0 +1,244 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://nx.dev/reference/project-configuration",
+  "title": "JSON schema for Nx projects",
+  "type": "object",
+  "properties": {
+    "namedInputs": {
+      "type": "object",
+      "description": "Named inputs used by inputs defined in targets",
+      "additionalProperties": {
+        "$ref": "#/definitions/inputs"
+      }
+    },
+    "targets": {
+      "type": "object",
+      "description": "Configures all the targets which define what tasks you can run against the project",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "executor": {
+            "description": "The function that Nx will invoke when you run this target",
+            "type": "string"
+          },
+          "options": {
+            "type": "object"
+          },
+          "outputs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "defaultConfiguration": {
+            "type": "string",
+            "description": "The name of a configuration to use as the default if a configuration is not provided"
+          },
+          "configurations": {
+            "type": "object",
+            "description": "provides extra sets of values that will be merged into the options map",
+            "additionalProperties": {
+              "type": "object"
+            }
+          },
+          "inputs": {
+            "$ref": "#/definitions/inputs"
+          },
+          "dependsOn": {
+            "type": "array",
+            "items": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "projects": {
+                      "oneOf": [
+                        {
+                          "type": "string",
+                          "description": "A project name"
+                        },
+                        {
+                          "type": "array",
+                          "description": "An array of project names",
+                          "items": {
+                            "type": "string"
+                          }
+                        }
+                      ]
+                    },
+                    "dependencies": {
+                      "type": "boolean"
+                    },
+                    "target": {
+                      "type": "string",
+                      "description": "The name of the target."
+                    },
+                    "params": {
+                      "type": "string",
+                      "description": "Configuration for params handling.",
+                      "enum": ["ignore", "forward"],
+                      "default": "ignore"
+                    }
+                  },
+                  "oneOf": [
+                    {
+                      "required": ["projects", "target"]
+                    },
+                    {
+                      "required": ["dependencies", "target"]
+                    },
+                    {
+                      "required": ["target"],
+                      "not": {
+                        "anyOf": [
+                          { "required": ["projects"] },
+                          { "required": ["dependencies"] }
+                        ]
+                      }
+                    }
+                  ],
+                  "additionalProperties": false
+                }
+              ]
+            }
+          },
+          "command": {
+            "type": "string",
+            "description": "A shorthand for using the nx:run-commands executor"
+          },
+          "cache": {
+            "type": "boolean",
+            "description": "Specifies if the given target should be cacheable"
+          }
+        }
+      }
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "implicitDependencies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "definitions": {
+    "inputs": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "object",
+            "properties": {
+              "fileset": {
+                "type": "string",
+                "description": "A glob used to determine a fileset."
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "projects": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "description": "The project that the targets belong to."
+                  },
+                  {
+                    "type": "array",
+                    "description": "The projects that the targets belong to.",
+                    "items": { "type": "string" }
+                  }
+                ]
+              },
+              "dependencies": {
+                "type": "boolean",
+                "description": "Include files belonging to the input for all the project dependencies of this target."
+              },
+              "input": {
+                "type": "string",
+                "description": "The name of the input."
+              }
+            },
+            "oneOf": [
+              {
+                "required": ["projects", "input"]
+              },
+              {
+                "required": ["dependencies", "input"]
+              },
+              {
+                "required": ["input"],
+                "not": {
+                  "anyOf": [
+                    { "required": ["projects"] },
+                    { "required": ["dependencies"] }
+                  ]
+                }
+              }
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "runtime": {
+                "type": "string",
+                "description": "The command that will be executed and included into the hash."
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "env": {
+                "type": "string",
+                "description": "The env var that will be included into the hash."
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "externalDependencies": {
+                "type": "array",
+                "items": { "type": "string" },
+                "description": "The list of external dependencies that our target depends on for `nx:run-commands` and community plugins."
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "dependentTasksOutputFiles": {
+                "type": "string",
+                "description": "The glob list of output files that project depends on."
+              },
+              "transitive": {
+                "type": "boolean",
+                "description": "Whether the check for outputs should be recursive or stop at the first level of dependencies."
+              }
+            },
+            "required": ["dependentTasksOutputFiles"],
+            "additionalProperties": false
+          }
+        ]
+      }
+    }
+  }
+}

package/schemas/workspace-schema.json

@@ -0,0 +1,185 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://nx.dev",
+  "title": "JSON schema for Nx workspaces",
+  "type": "object",
+  "properties": {
+    "version": {
+      "type": "number",
+      "enum": [1, 2]
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "version": { "const": 2 } },
+        "required": ["version"]
+      },
+      "then": {
+        "properties": {
+          "projects": {
+            "type": "object",
+            "additionalProperties": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "targets": {
+                      "type": "object",
+                      "description": "Configures all the targets which define what tasks you can run against the project",
+                      "additionalProperties": {
+                        "type": "object",
+                        "properties": {
+                          "executor": {
+                            "description": "The function that Nx will invoke when you run this target",
+                            "type": "string"
+                          },
+                          "options": {
+                            "type": "object"
+                          },
+                          "outputs": {
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
+                          "configurations": {
+                            "type": "object",
+                            "description": "provides extra sets of values that will be merged into the options map",
+                            "additionalProperties": {
+                              "type": "object"
+                            }
+                          },
+                          "dependsOn": {
+                            "type": "array",
+                            "description": "Target dependency.",
+                            "items": {
+                              "oneOf": [
+                                {
+                                  "type": "string"
+                                },
+                                {
+                                  "type": "object",
+                                  "properties": {
+                                    "projects": {
+                                      "oneOf": [
+                                        {
+                                          "type": "string",
+                                          "description": "A project name"
+                                        },
+                                        {
+                                          "type": "array",
+                                          "description": "An array of project names",
+                                          "items": {
+                                            "type": "string"
+                                          }
+                                        }
+                                      ]
+                                    },
+                                    "dependencies": {
+                                      "type": "boolean"
+                                    },
+                                    "target": {
+                                      "type": "string",
+                                      "description": "The name of the target."
+                                    },
+                                    "params": {
+                                      "type": "string",
+                                      "description": "Configuration for params handling.",
+                                      "enum": ["ignore", "forward"],
+                                      "default": "ignore"
+                                    }
+                                  },
+                                  "oneOf": [
+                                    {
+                                      "required": ["projects", "target"]
+                                    },
+                                    {
+                                      "required": ["dependencies", "target"]
+                                    },
+                                    {
+                                      "required": ["target"],
+                                      "not": {
+                                        "anyOf": [
+                                          { "required": ["projects"] },
+                                          { "required": ["dependencies"] }
+                                        ]
+                                      }
+                                    }
+                                  ],
+                                  "additionalProperties": false
+                                }
+                              ]
+                            }
+                          },
+                          "command": {
+                            "type": "string",
+                            "description": "A shorthand for using the nx:run-commands executor"
+                          },
+                          "cache": {
+                            "type": "boolean",
+                            "description": "Specifies if the given target should be cacheable"
+                          }
+                        }
+                      }
+                    },
+                    "tags": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "implicitDependencies": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "else": {
+        "properties": {
+          "projects": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "properties": {
+                "architect": {
+                  "type": "object",
+                  "description": "Configures all the targets which define what tasks you can run against the project",
+                  "additionalProperties": {
+                    "type": "object",
+                    "properties": {
+                      "builder": {
+                        "description": "The function that Nx will invoke when you run this architect",
+                        "type": "string"
+                      },
+                      "options": {
+                        "type": "object"
+                      },
+                      "configurations": {
+                        "type": "object",
+                        "description": "provides extra sets of values that will be merged into the options map",
+                        "additionalProperties": {
+                          "type": "object"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/src/adapter/angular-json.d.ts

@@ -0,0 +1,9 @@
+import { ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxPluginV2 } from '../utils/nx-plugin';
+export declare const NX_ANGULAR_JSON_PLUGIN_NAME = "nx-angular-json-plugin";
+export declare const NxAngularJsonPlugin: NxPluginV2;
+export declare function shouldMergeAngularProjects(root: string, includeProjectsFromAngularJson: boolean): boolean;
+export declare function isAngularPluginInstalled(): boolean;
+export declare function toNewFormat(w: any): ProjectsConfigurations;
+export declare function toOldFormat(w: any): any;
+export declare function renamePropertyWithStableKeys(obj: any, from: string, to: string): void;

package/src/adapter/angular-json.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renamePropertyWithStableKeys = exports.toOldFormat = exports.toNewFormat = exports.isAngularPluginInstalled = exports.shouldMergeAngularProjects = exports.NxAngularJsonPlugin = exports.NX_ANGULAR_JSON_PLUGIN_NAME = void 0;
+const fs_1 = require("fs");
+const path = require("path");
+const fileutils_1 = require("../utils/fileutils");
+exports.NX_ANGULAR_JSON_PLUGIN_NAME = 'nx-angular-json-plugin';
+exports.NxAngularJsonPlugin = {
+    name: exports.NX_ANGULAR_JSON_PLUGIN_NAME,
+    createNodes: [
+        'angular.json',
+        (f, _, ctx) => ({
+            projects: readAngularJson(ctx.workspaceRoot),
+        }),
+    ],
+};
+function shouldMergeAngularProjects(root, includeProjectsFromAngularJson) {
+    if ((0, fs_1.existsSync)(path.join(root, 'angular.json')) &&
+        // Include projects from angular.json if explicitly required.
+        // e.g. when invoked from `packages/devkit/src/utils/convert-nx-executor.ts`
+        (includeProjectsFromAngularJson ||
+            // Or if a workspace has `@nrwl/angular`/`@nx/angular` installed then projects from `angular.json` to be considered by Nx.
+            isAngularPluginInstalled())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.shouldMergeAngularProjects = shouldMergeAngularProjects;
+function isAngularPluginInstalled() {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/angular');
+        return true;
+    }
+    catch {
+        try {
+            require.resolve('@nrwl/angular');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.isAngularPluginInstalled = isAngularPluginInstalled;
+function readAngularJson(angularCliWorkspaceRoot) {
+    return toNewFormat((0, fileutils_1.readJsonFile)(path.join(angularCliWorkspaceRoot, 'angular.json'))).projects;
+}
+function toNewFormat(w) {
+    if (!w.projects) {
+        return w;
+    }
+    for (const name in w.projects ?? {}) {
+        const projectConfig = w.projects[name];
+        if (projectConfig.architect) {
+            renamePropertyWithStableKeys(projectConfig, 'architect', 'targets');
+        }
+        if (projectConfig.schematics) {
+            renamePropertyWithStableKeys(projectConfig, 'schematics', 'generators');
+        }
+        if (!projectConfig.name) {
+            projectConfig.name = name;
+        }
+        Object.values(projectConfig.targets || {}).forEach((target) => {
+            if (target.builder !== undefined) {
+                renamePropertyWithStableKeys(target, 'builder', 'executor');
+            }
+        });
+    }
+    if (w.schematics) {
+        renamePropertyWithStableKeys(w, 'schematics', 'generators');
+    }
+    if (w.version !== 2) {
+        w.version = 2;
+    }
+    return w;
+}
+exports.toNewFormat = toNewFormat;
+function toOldFormat(w) {
+    if (w.projects) {
+        for (const name in w.projects) {
+            const projectConfig = w.projects[name];
+            if (typeof projectConfig === 'string') {
+                throw new Error("'project.json' files are incompatible with version 1 workspace schemas.");
+            }
+            if (projectConfig.targets) {
+                renamePropertyWithStableKeys(projectConfig, 'targets', 'architect');
+            }
+            if (projectConfig.generators) {
+                renamePropertyWithStableKeys(projectConfig, 'generators', 'schematics');
+            }
+            delete projectConfig.name;
+            Object.values(projectConfig.architect || {}).forEach((target) => {
+                if (target.executor !== undefined) {
+                    renamePropertyWithStableKeys(target, 'executor', 'builder');
+                }
+            });
+        }
+    }
+    if (w.generators) {
+        renamePropertyWithStableKeys(w, 'generators', 'schematics');
+    }
+    if (w.version !== 1) {
+        w.version = 1;
+    }
+    return w;
+}
+exports.toOldFormat = toOldFormat;
+// we have to do it this way to preserve the order of properties
+// not to screw up the formatting
+function renamePropertyWithStableKeys(obj, from, to) {
+    const copy = { ...obj };
+    Object.keys(obj).forEach((k) => {
+        delete obj[k];
+    });
+    Object.keys(copy).forEach((k) => {
+        if (k === from) {
+            obj[to] = copy[k];
+        }
+        else {
+            obj[k] = copy[k];
+        }
+    });
+}
+exports.renamePropertyWithStableKeys = renamePropertyWithStableKeys;

package/src/adapter/compat.d.ts

@@ -0,0 +1,2 @@
+export declare const allowedProjectExtensions: readonly ["tags", "implicitDependencies", "configFilePath", "$schema", "generators", "namedInputs", "name", "files", "root", "sourceRoot", "projectType", "release", "includedScripts"];
+export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess"];