nx-lifecycle 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# nx-lifecycle
+
+## 0.0.2
+
+### Patch Changes
+
+- 31f81fa: Internal dependency updates
+- 689ef38: Add README
+- 3e7ee18: Dependency bumps
+- f6a4729: Update year in LICENSE
+- 9c786d0: Update dependencies
+- Updated dependencies [3dc29d2]
+- Updated dependencies [31f81fa]
+- Updated dependencies [3e7ee18]
+- Updated dependencies [f6a4729]
+- Updated dependencies [cab8478]
+- Updated dependencies [c2c0990]
+- Updated dependencies [9c786d0]
+- Updated dependencies [5984ed5]
+  - haywire@0.1.0
+  - juniper@1.1.11
+  - common-proxy@0.0.2
+  - default-import@1.1.6
+  - format-file@0.0.5
+  - nx-plugin-handler@0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jacob Ley
+
+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/README.md

@@ -0,0 +1,196 @@
+<div style="text-align:center">
+
+# nx-lifecycle
+An [Nx](https://nx.dev/) plugin that injects specific targets into high level workflows.
+
+[![npm package](https://badge.fury.io/js/nx-lifecycle.svg)](https://www.npmjs.com/package/nx-lifecycle)
+[![License](https://img.shields.io/npm/l/nx-lifecycle.svg)](https://github.com/JacobLey/leyman/blob/main/tools/nx-lifecycle/LICENSE)
+
+</div>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Usage](#usage)
+- [API](#api)
+    - [check](#check)
+    - [dryRun](#dryrun)
+
+## Introduction
+
+Nx targets achieve a specific task, such as loading external config, codegen, type checking, formatting, test execution or enforcing code coverage. 
+
+Some of these tasks depend on each other, others can be executed in parallel.
+
+Nx uses the target's [dependsOn](https://nx.dev/reference/project-configuration#dependson) field to natively manage this, and will execute tasks whenever all dependencies are successfully complete.
+
+In practice, this quickly becomes unweildy. In order to properly configure a given task, you have to have full context about all other tasks (including those of your dependencies). You also need to make sure all dependents are updated whenever you add another step to a task.
+
+For example, perhaps your code contains a typescript build step [nx-tsc](https://www.npmjs.com/package/nx-tsc), followed by a unit test [mocha](https://mochajs.org/). An initial config will look like:
+
+```json
+{
+    "targets": {
+        "nx-tsc": {
+            "dependsOn": ["^nx-tsc"]
+        },
+        "mocha": {
+            "dependsOn": ["nx-tsc"]
+        },
+    }
+}
+```
+
+Your mocha task depends on the nx-tsc first, and nx-tsc depends on any of _its_ dependencies to be built first.
+
+Now what if you need want to add a step _after_ to your build? Perhaps you want to use your recently built JS code to [generate a JSON config](https://www.npmjs.com/package/nx-populate-files).
+
+Now your mocha command needs to update to depend on that populate step, rather than `nx-tsc`. Your `nx-tsc` command _also_ needs to update its dependencies to depend on that task, rather than `nx-tsc`. But only if your dependencies include this populate step!
+
+Instead of simply adding this new task, you now need to conditionally manage the dependecones on two other tasks! Imagine how this problem can grow as we begin to support more tasks like type checking, code coverage, or codegen. Each implemented slightly different in each package, especailly if you use more than one language in your monorepo!
+
+`nx-lifecycle` is the solution to this problem, by breaking down the solution into two steps:
+
+### High level tasks
+
+We define abstract workflows that can optionally be used across any and all projects, regardless of language, purpose, or implementation.
+
+An example would breaking up general steps around a build/compile step, a formatter/linter, and test execution/coverage. We can fairly safely say that the build step will depend on our dependencies build steps, and test execution will depend on our own projects build step.
+
+Then we split up these high level tasks into even simpler tasks.
+An example would be our test suite may contain both unit-tests and functional tests, and then a final step to enforce the resulting code coverage achieves acceptable levels.
+
+Note these steps are still abstract, and it is not necessary that every project is capable of implementing every task.
+
+### Bind implementions to tasks
+
+Now we can bind project specific implementations to each abstract task.
+
+In the original example, perhaps we bind our `nx-tsc` target to a `build:run` step, and our `nx-populate-files` step to a `build:post` step.
+
+Then our `mocha` target can be bound to a `test:unit` step.
+
+You can bind multiple targets to a single step. For example if your code also includes some Java projects, you might also bind your [@nx/gradle](https://nx.dev/nx-api/gradle]) target to `build:run`.
+
+### Instrumenting your `nx.json` and `project.json`
+
+Now that you configured your abstract tasks and bound implementations, `nx-lifecycle` will update your `nx.json` and relevant `project.json` files will all the `dependsOn` to make your code run efficiently and deterministically!
+
+Any time you want to add or remove targets for a project, simply re-run `nx-lifecycle`'s plugin and all dependencies are up to date!
+
+## Installation
+
+`npm i nx-lifecycle`
+
+Register it as a target in a `project.json`:
+```json
+{
+    "targets": {
+        "lifecycle": {
+            "executor": "nx-lifecycle:lifecycle",
+            "options": {
+                "stages": {
+                    "build": { 
+                        "hooks": ["pre", "run", "post"], 
+                        "dependsOn": ["^build"]
+                    },
+                    "test": {
+                        "hooks": ["run", "report"],
+                        "dependsOn": ["build"]
+                    }
+                },
+                "bindings": {
+                    "nx-tsc": "build:run",
+                    "mocha": "test:run"
+                }
+            }
+        }
+    }
+}
+```
+
+Note that this target only needs to be run once (not once per project) so it is recommended to put this somewhere like a root `project.json` to own this.
+
+## Usage
+
+Because the `lifecycle` executor manages target dependencies itself, it probably should not be executed along with targets that are normally executed, like the `build` and `test` targets in the example above.
+
+For example, this project's use of `nx-lifecycle` is part of a [local-only project](https://github.com/JacobLey/leyman/blob/main/leyman/main/project.json#L15) that is never deployed anywhere, and exists only to manage the repo itself.
+
+`nx-lifecycle` will produce additional targets in your `nx.json` and `project.json`s. These will all be backed by the [noop](https://nx.dev/nx-api/nx/executors/noop) executor, and have no need to invoke caching. In fact, you should never directly manage these commands, their dependencies, or their configurations.
+
+You may declare one-off targets that _depend_ on these targets though, that is the whole point! You should able to declare a target depends on the build step, without having to explicitly manage how the build script is implemented.
+
+`nx-lifecycle` will use the `nx.json` to assign defaults, and will assign defaults to your targets that are assigned there. However that does not guarantee every target is actually executable by every project. You must declare the target in your `project.json` as well. Do not worry about copying `nx-lifecycle`'s targets over.
+
+## Executors
+
+### lifecycle
+
+Will update all `project.json`s and the `nx.json` with declared stages, and wire up dependencies to your bound targets, ensuring that you can reference your abstract targets, Nx will invoke the required targets in dependency order as necessary.
+
+Requires configuration to execute.
+
+#### configuration.stages
+
+Required. No default value.
+
+This is the [high level tasks](#high-level-tasks) logic as described above. Declares the generic targets to be owned by `nx-lifecycle`, which represent workflows with potentially multiple steps.
+
+It is an object, where every key is the name of a stage. The value is another object that optionally has two fields:
+
+- `steps`
+  - A list of "sub-stages" to be executed in order. The resulting name of the target will be delimeted by a colon: `stage:step`.
+- `dependsOn`
+  - Accepts the same values as normal Nx [dependsOn](https://nx.dev/reference/project-configuration#dependson). Used to define relationship between stages, and their dependencies.
+
+#### configuration.bindings
+
+Required. No default value.
+
+This is [bind implementions to tasks](#bind-implementions-to-tasks) logic as described above.
+
+The value is an object mapping, where the key is the name of your specific target implementations (e.g. `nx-tsc` or `mocha`) and the value is the stage it maps to.
+
+__\*\*NOTE\*\*__ If the bound stage has `steps` defined, then you must bind to a specific step. If there are no steps, then you reference the stage directly.
+
+```
+{
+    "targets": {
+        "lifecycle": {
+            "executor": "nx-lifecycle:lifecycle",
+            "options": {
+                "stages": {
+                    "build": { 
+                        "dependsOn": ["^build"]
+                    },
+                    "test": {
+                        "hooks": ["run", "report"],
+                        "dependsOn": ["build"]
+                    }
+                },
+                "bindings": {
+                    "nx-tsc": "build",
+                    "mocha": "test:run"
+                }
+            }
+        }
+    }
+}
+```
+
+#### configuration.check
+
+`boolean`. Default `true` in CI environments, otherwise `false`.
+
+If `true`, the executor will fail if the `nx.json` or any `project.json` is out of sync with what `nx-lifecycle` believes is correct.
+
+Useful for ensuring that generated configs are up to date in version control before proceeding with deployments.
+
+#### configuration.dryRun
+
+`boolean`. Default `false`.
+
+If `true`, will do everything except actually write the updated config files.
+
+Can still fail if `check` is `true`.

package/dist/executors/lifecycle/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NOOP_EXECUTOR = "nx:noop";
+//# sourceMappingURL=constants.d.ts.map

package/dist/executors/lifecycle/constants.js

@@ -0,0 +1,2 @@
+export const NOOP_EXECUTOR = 'nx:noop';
+//# sourceMappingURL=constants.js.map

package/dist/executors/lifecycle/depedencies.d.ts

@@ -0,0 +1,13 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { type FilesFormatter } from 'format-file';
+export interface Logger {
+    info: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export declare const readFileIdentifier: import("haywire").HaywireId<typeof readFile, null, null, false, false, false, false>;
+export declare const writeFileIdentifier: import("haywire").HaywireId<typeof writeFile, null, null, false, false, false, false>;
+export declare const formatFileIdentifier: import("haywire").HaywireId<FilesFormatter, null, null, false, false, false, false>;
+export declare const isCiIdentifier: import("haywire").HaywireId<boolean, null, "isCI", false, false, false, false>;
+export declare const loggerIdentifier: import("haywire").HaywireId<Logger, null, null, false, false, false, false>;
+export declare const dependenciesModule: import("haywire").Module<[import("haywire").NonExtendable<typeof readFile | null | undefined, null, null>] | [import("haywire").NonExtendable<typeof readFile | null, null, null>] | [import("haywire").NonExtendable<typeof readFile | undefined, null, null>] | [import("haywire").NonExtendable<typeof readFile, null, null>] | [import("haywire").NonExtendable<typeof writeFile | null | undefined, null, null>] | [import("haywire").NonExtendable<typeof writeFile | null, null, null>] | [import("haywire").NonExtendable<typeof writeFile | undefined, null, null>] | [import("haywire").NonExtendable<typeof writeFile, null, null>] | [import("haywire").NonExtendable<FilesFormatter | null | undefined, null, null>] | [import("haywire").NonExtendable<FilesFormatter | null, null, null>] | [import("haywire").NonExtendable<FilesFormatter | undefined, null, null>] | [import("haywire").NonExtendable<FilesFormatter, null, null>] | [import("haywire").NonExtendable<boolean | null | undefined, null, "isCI">] | [import("haywire").NonExtendable<boolean | null, null, "isCI">] | [import("haywire").NonExtendable<boolean | undefined, null, "isCI">] | [import("haywire").NonExtendable<boolean, null, "isCI">] | [import("haywire").NonExtendable<Logger | null | undefined, null, null>] | [import("haywire").NonExtendable<Logger | null, null, null>] | [import("haywire").NonExtendable<Logger | undefined, null, null>] | [import("haywire").NonExtendable<Logger, null, null>], never, false>;
+//# sourceMappingURL=depedencies.d.ts.map

package/dist/executors/lifecycle/depedencies.js

@@ -0,0 +1,11 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { isCI } from 'ci-info';
+import { formatFiles } from 'format-file';
+import { bind, createModule, identifier } from 'haywire';
+export const readFileIdentifier = identifier();
+export const writeFileIdentifier = identifier();
+export const formatFileIdentifier = identifier();
+export const isCiIdentifier = identifier().named('isCI');
+export const loggerIdentifier = identifier();
+export const dependenciesModule = createModule(bind(readFileIdentifier).withInstance(readFile)).addBinding(bind(writeFileIdentifier).withInstance(writeFile)).addBinding(bind(formatFileIdentifier).withInstance(formatFiles)).addBinding(bind(isCiIdentifier).withInstance(isCI)).addBinding(bind(loggerIdentifier).withInstance(console));
+//# sourceMappingURL=depedencies.js.map

package/dist/executors/lifecycle/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _commonproxy = require("common-proxy");
+const _default = (0, _commonproxy.commonProxy)(import('./index.js'));
+//# sourceMappingURL=index.cjs.map

package/dist/executors/lifecycle/index.d.cts

@@ -0,0 +1,49 @@
+declare const _default: (options: Partial<{
+    check: boolean;
+    dryRun: boolean;
+    stages: Record<string, Partial<{
+        dependsOn: ((string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>)) & (string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | undefined))[];
+        hooks: string[];
+    }>>;
+    bindings: Record<string, string>;
+}>, context: import("@nx/devkit").ExecutorContext) => Promise<{
+    success: boolean;
+}>;
+export default _default;
+//# sourceMappingURL=index.d.cts.map

package/dist/executors/lifecycle/index.d.ts

@@ -0,0 +1,47 @@
+declare const _default: import("nx-plugin-handler").RawHandler<Partial<{
+    check: boolean;
+    dryRun: boolean;
+    stages: Record<string, Partial<{
+        dependsOn: ((string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>)) & (string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | undefined))[];
+        hooks: string[];
+    }>>;
+    bindings: Record<string, string>;
+}>>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/executors/lifecycle/index.js

@@ -0,0 +1,22 @@
+import { bind, createContainer, createModule } from 'haywire';
+import { handler } from 'nx-plugin-handler';
+import { isNxJson, isNxJsonIdentifier, isProjectJson, isProjectJsonIdentifier } from '#schemas';
+import { dependenciesModule, formatFileIdentifier, isCiIdentifier, loggerIdentifier, readFileIdentifier, writeFileIdentifier } from './depedencies.js';
+import { Lifecycle } from './lifecycle.js';
+import { Normalizer } from './normalizer.js';
+import { nxAndProjectJsonProcessorIdentifier, processNxAndProjectJsons } from './processor.js';
+const pluginModule = createModule(bind(Lifecycle).withConstructorProvider().withDependencies([
+    Normalizer,
+    readFileIdentifier,
+    writeFileIdentifier,
+    formatFileIdentifier,
+    nxAndProjectJsonProcessorIdentifier,
+    isNxJsonIdentifier,
+    isProjectJsonIdentifier,
+    loggerIdentifier
+])).addBinding(bind(Normalizer).withConstructorProvider().withDependencies([
+    isCiIdentifier
+])).addBinding(bind(nxAndProjectJsonProcessorIdentifier).withInstance(processNxAndProjectJsons)).addBinding(bind(isNxJsonIdentifier).withInstance(isNxJson)).addBinding(bind(isProjectJsonIdentifier).withInstance(isProjectJson));
+const lifecycle = createContainer(dependenciesModule.mergeModule(pluginModule)).get(Lifecycle);
+export default handler(lifecycle.lifecycle.bind(lifecycle));
+//# sourceMappingURL=index.js.map

package/dist/executors/lifecycle/lifecycle.d.ts

@@ -0,0 +1,23 @@
+import type * as fs from 'node:fs/promises';
+import type { FilesFormatter } from 'format-file';
+import type { IsNxJson, IsProjectJson } from '#schemas';
+import type { Logger } from './depedencies.js';
+import type { Normalizer } from './normalizer.js';
+import type { NxAndProjectJsonProcessor } from './processor.js';
+import type { LifecycleOptions } from './schema.js';
+import type { SimpleExecutorContext } from './types.js';
+/**
+ * Main logic for lifecycle file management.
+ *
+ * Loads the `nx.json` + `project.json`s for all projects,
+ * calculates the new targets and dependencies,
+ * and re-writes files as appropriate.
+ */
+export declare class Lifecycle {
+    #private;
+    constructor(normalizer: Normalizer, readFile: (typeof fs)['readFile'], writeFile: (typeof fs)['writeFile'], formatFiles: FilesFormatter, processNxAndProjectJsons: NxAndProjectJsonProcessor, isNxJson: IsNxJson, isProjectJson: IsProjectJson, logger: Logger);
+    lifecycle(options: LifecycleOptions, context: SimpleExecutorContext): Promise<{
+        success: boolean;
+    }>;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/executors/lifecycle/lifecycle.js

@@ -0,0 +1,102 @@
+import { deepEqual } from 'fast-equals';
+export class Lifecycle {
+    #normalizer;
+    #readFile;
+    #writeFile;
+    #formatFiles;
+    #processNxAndProjectJsons;
+    #isNxJson;
+    #isProjectJson;
+    #logger;
+    constructor(normalizer, readFile, writeFile, formatFiles, processNxAndProjectJsons, isNxJson, isProjectJson, logger){
+        this.#normalizer = normalizer;
+        this.#readFile = readFile;
+        this.#writeFile = writeFile;
+        this.#formatFiles = formatFiles;
+        this.#processNxAndProjectJsons = processNxAndProjectJsons;
+        this.#isNxJson = isNxJson;
+        this.#isProjectJson = isProjectJson;
+        this.#logger = logger;
+    }
+    async lifecycle(options, context) {
+        const normalized = this.#normalizer.normalizeOptions(options, context);
+        const { nxJson, projectJsons } = await this.#loadJsonConfigs(normalized);
+        const { processedNxJson, processedProjectJsons } = this.#processNxAndProjectJsons({
+            nxJson: nxJson.data,
+            projectJsons: projectJsons.map(({ data })=>data),
+            options: normalized
+        });
+        await this.#saveJsonConfigs({
+            jsons: [
+                {
+                    ...nxJson,
+                    processed: processedNxJson
+                },
+                ...projectJsons.map((projectJson, i)=>({
+                        ...projectJson,
+                        processed: processedProjectJsons[i]
+                    }))
+            ],
+            options: normalized
+        });
+        return {
+            success: true
+        };
+    }
+    async #loadJsonConfigs({ nxJsonPath, packageJsonPaths }) {
+        const [rawNxJson, ...rawProjectJsons] = await Promise.all([
+            this.#readFile(nxJsonPath, 'utf8'),
+            ...packageJsonPaths.map(async ({ name, path })=>({
+                    name,
+                    path,
+                    rawData: await this.#readFile(path, 'utf8')
+                }))
+        ]);
+        const parsedNxJson = JSON.parse(rawNxJson);
+        if (!this.#isNxJson(parsedNxJson)) {
+            throw new Error(`Failed to parse nx.json: ${JSON.stringify(this.#isNxJson.errors, null, 2)}`);
+        }
+        return {
+            nxJson: {
+                name: 'nx.json',
+                path: nxJsonPath,
+                data: parsedNxJson
+            },
+            projectJsons: rawProjectJsons.map(({ name, path, rawData })=>{
+                const data = JSON.parse(rawData);
+                if (!this.#isProjectJson(data)) {
+                    throw new Error(`Failed to parse ${path}: ${JSON.stringify(this.#isProjectJson.errors, null, 2)}`);
+                }
+                return {
+                    name,
+                    path,
+                    data
+                };
+            })
+        };
+    }
+    async #saveJsonConfigs({ jsons, options }) {
+        const filesToUpdate = [];
+        for (const { path, data, processed } of jsons){
+            if (deepEqual(data, processed)) {
+                continue;
+            }
+            if (options.check) {
+                throw new Error(`File ${path} is not up to date`);
+            }
+            filesToUpdate.push({
+                path,
+                processed
+            });
+        }
+        await Promise.all(filesToUpdate.map(async ({ path, processed })=>{
+            this.#logger.info(`Updating ${path}`);
+            if (options.dryRun) {
+                return;
+            }
+            return this.#writeFile(path, JSON.stringify(processed), 'utf8');
+        }));
+        await this.#formatFiles(filesToUpdate.map((file)=>file.path));
+    }
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/executors/lifecycle/normalizer.d.ts

@@ -0,0 +1,23 @@
+import type { LifecycleOptions } from './schema.js';
+import type { SimpleExecutorContext } from './types.js';
+export interface NormalizedOptions {
+    check: boolean;
+    dryRun: boolean;
+    nxJsonPath: string;
+    packageJsonPaths: {
+        name: string;
+        path: string;
+    }[];
+    stages: NonNullable<LifecycleOptions['stages']>;
+    bindings: NonNullable<LifecycleOptions['bindings']>;
+}
+/**
+ * Standardizes the options passed to this executor,
+ * based on input, reasonable defaults, and project state.
+ */
+export declare class Normalizer {
+    #private;
+    constructor(isCI: boolean);
+    normalizeOptions(options: LifecycleOptions, context: SimpleExecutorContext): NormalizedOptions;
+}
+//# sourceMappingURL=normalizer.d.ts.map

package/dist/executors/lifecycle/normalizer.js

@@ -0,0 +1,21 @@
+import Path from 'node:path';
+export class Normalizer {
+    #isCI;
+    constructor(isCI){
+        this.#isCI = isCI;
+    }
+    normalizeOptions(options, context) {
+        return {
+            check: options.check ?? this.#isCI,
+            dryRun: options.dryRun ?? false,
+            nxJsonPath: Path.join(context.root, 'nx.json'),
+            packageJsonPaths: Object.values(context.projectsConfigurations.projects).map((projectConfig)=>({
+                    name: projectConfig.name,
+                    path: Path.join(context.root, projectConfig.root, 'project.json')
+                })),
+            stages: options.stages ?? {},
+            bindings: options.bindings ?? {}
+        };
+    }
+}
+//# sourceMappingURL=normalizer.js.map

package/dist/executors/lifecycle/processor.d.ts

@@ -0,0 +1,15 @@
+import { type NxJson, type ProjectJson } from '#schemas';
+import type { NormalizedOptions } from './normalizer.js';
+type ProcessorOptions = Pick<NormalizedOptions, 'bindings' | 'stages'>;
+export type NxAndProjectJsonProcessor = ({ nxJson, projectJsons, options, }: {
+    nxJson: NxJson;
+    projectJsons: ProjectJson[];
+    options: ProcessorOptions;
+}) => {
+    processedNxJson: NxJson;
+    processedProjectJsons: ProjectJson[];
+};
+export declare const nxAndProjectJsonProcessorIdentifier: import("haywire").HaywireId<NxAndProjectJsonProcessor, null, null, false, false, false, false>;
+export declare const processNxAndProjectJsons: NxAndProjectJsonProcessor;
+export {};
+//# sourceMappingURL=processor.d.ts.map