@aws/nx-plugin 1.0.0-rc.7 → 1.0.0-rc.71

package/src/license/config.js

@@ -1,50 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readLicenseConfig = exports.writeLicenseConfig = exports.defaultLicenseConfig = exports.ensurePythonLicenseCollector = exports.ensureLicenseExceptions = exports.ensureDependencyCheckBlock = exports.addLicenseCheckToAllLintTargets = exports.addLicenseCheckToLintTarget = exports.updateLicenseCheckTargetInputs = exports.LANGUAGE_COMMENT_SYNTAX = void 0;
-const utils_1 = require("../utils/config/utils");
-const format_1 = require("../utils/format");
-const nx_1 = require("../utils/nx");
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { getProjects, readProjectConfiguration, updateProjectConfiguration } from "@nx/devkit";
+import { AWS_NX_PLUGIN_CONFIG_FILE_NAME, readAwsNxPluginConfig, updateAwsNxPluginConfig } from "../utils/config/utils.js";
+import { formatFilesInSubtree } from "../utils/format.js";
+import { addDependencyToTargetIfNotPresent } from "../utils/nx.js";
 /**
  * Licenses containing a placeholder for the copyright year.
- */
-const LICENSES_WITH_YEAR = new Set(['MIT']);
+ */ const LICENSES_WITH_YEAR = new Set([
+    'MIT'
+]);
 /**
  * Defines the comment syntax for popular programming languages
- */
-exports.LANGUAGE_COMMENT_SYNTAX = {
+ */ export const LANGUAGE_COMMENT_SYNTAX = {
     // C++ style comments
     ...Object.fromEntries([
         // Node
@@ -85,8 +53,17 @@ exports.LANGUAGE_COMMENT_SYNTAX = {
         // Kotlin
         'kt',
         // Swift
-        'swift',
-    ].map((ext) => [ext, { line: '//', block: { start: '/*', end: '*/' } }])),
+        'swift'
+    ].map((ext)=>[
+            ext,
+            {
+                line: '//',
+                block: {
+                    start: '/*',
+                    end: '*/'
+                }
+            }
+        ])),
     // Bash style comments
     ...Object.fromEntries([
         // Bash
@@ -97,48 +74,119 @@ exports.LANGUAGE_COMMENT_SYNTAX = {
         'yaml',
         'yml',
         // R
-        'r',
-    ].map((ext) => [ext, { line: '#' }])),
+        'r'
+    ].map((ext)=>[
+            ext,
+            {
+                line: '#'
+            }
+        ])),
     // Docker
-    Dockerfile: { line: '#' },
+    Dockerfile: {
+        line: '#'
+    },
     // Python
-    py: { line: '#', block: { start: '"""', end: '"""' } },
+    py: {
+        line: '#',
+        block: {
+            start: '"""',
+            end: '"""'
+        }
+    },
     // Web
-    html: { block: { start: '<!--', end: '-->' } },
-    css: { block: { start: '/*', end: '*/' } },
+    html: {
+        block: {
+            start: '<!--',
+            end: '-->'
+        }
+    },
+    css: {
+        block: {
+            start: '/*',
+            end: '*/'
+        }
+    },
     // Ruby
-    rb: { line: '#', block: { start: '=begin', end: '=end' } },
+    rb: {
+        line: '#',
+        block: {
+            start: '=begin',
+            end: '=end'
+        }
+    },
     // F#
-    ...Object.fromEntries(['fs', 'fsx'].map((ext) => [
-        ext,
-        { line: '//', block: { start: '(*', end: '*)' } },
-    ])),
+    ...Object.fromEntries([
+        'fs',
+        'fsx'
+    ].map((ext)=>[
+            ext,
+            {
+                line: '//',
+                block: {
+                    start: '(*',
+                    end: '*)'
+                }
+            }
+        ])),
     // Visual Basic
-    vb: { line: "' " },
+    vb: {
+        line: "' "
+    },
     // Lua
-    lua: { line: '--', block: { start: '--[[', end: ']]' } },
+    lua: {
+        line: '--',
+        block: {
+            start: '--[[',
+            end: ']]'
+        }
+    },
     // PowerShell
-    ps1: { line: '#', block: { start: '<#', end: '#>' } },
-    psm1: { line: '#', block: { start: '<#', end: '#>' } },
+    ps1: {
+        line: '#',
+        block: {
+            start: '<#',
+            end: '#>'
+        }
+    },
+    psm1: {
+        line: '#',
+        block: {
+            start: '<#',
+            end: '#>'
+        }
+    },
     // Markdown
-    md: { block: { start: '<!--', end: '-->' } },
+    md: {
+        block: {
+            start: '<!--',
+            end: '-->'
+        }
+    },
     // Terraform
-    tf: { line: '#', block: { start: '/*', end: '*/' } },
+    tf: {
+        line: '#',
+        block: {
+            start: '/*',
+            end: '*/'
+        }
+    },
     // Smithy
-    smithy: { line: '//' },
+    smithy: {
+        line: '//'
+    }
 };
 /**
  * Module specifier for the license helpers exported by this package, used by
  * imports written into the user's config file.
- */
-const LICENSE_SDK_MODULE = '@aws/nx-plugin/sdk/license';
+ */ const LICENSE_SDK_MODULE = '@aws/nx-plugin/sdk/license';
 /**
  * Build the object literal source for a dependency check exception.
  * `JSON.stringify` produces valid string literals for arbitrary text (quotes,
  * backslashes, newlines all escaped); prettier later normalises quote style.
- */
-const exceptionLiteral = (exception) => {
-    const parts = [`package: ${JSON.stringify(exception.package)}`];
+ */ const exceptionLiteral = (exception)=>{
+    const parts = [
+        `package: ${JSON.stringify(exception.package)}`
+    ];
     if (exception.version !== undefined) {
         parts.push(`version: ${JSON.stringify(exception.version)}`);
     }
@@ -156,8 +204,7 @@ const exceptionLiteral = (exception) => {
  *   - otherwise        → list-append `+=` of `, $ins`; the leading comma is the
  *     element separator and `+=` places it correctly for single inline,
  *     single-with-trailing-comma and multi-element arrays alike
- */
-const appendToArray = (key, ins) => `or {
+ */ const appendToArray = (key, ins)=>`or {
     $scope <: contains \`${key}: []\` => \`${key}: [${ins}]\`,
     $scope <: contains \`${key}: [$items]\` where { $items += \`, ${ins}\` }
   }`;
@@ -170,38 +217,33 @@ const appendToArray = (key, ins) => `or {
  * is an object/array literal (e.g. `source: { ... }`), corrupting the file. The
  * property text is routed through a placeholder so its content never enters the
  * GritQL pattern. Returns true if the file changed (a `license` object existed).
- */
-const prependLicenseProperty = async (tree, property) => {
-    const { insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
+ */ const prependLicenseProperty = async (tree, property)=>{
+    const { insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await import("../utils/ast.js");
     // Non-empty license object: insert before the first existing property.
-    const intoNonEmpty = await insertViaGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`license: { $props }\` where { $props => \`${GRIT_INSERT_PLACEHOLDER}, $props\` }`, property);
-    if (intoNonEmpty)
-        return true;
+    const intoNonEmpty = await insertViaGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`license: { $props }\` where { $props => \`${GRIT_INSERT_PLACEHOLDER}, $props\` }`, property);
+    if (intoNonEmpty) return true;
     // Empty license object: `{ $props }` doesn't match `{}`, so fill it directly.
-    return insertViaGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`license: {}\` => \`license: { ${GRIT_INSERT_PLACEHOLDER} }\``, property);
+    return insertViaGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`license: {}\` => \`license: { ${GRIT_INSERT_PLACEHOLDER} }\``, property);
 };
 /**
  * Whether `license.dependencies` (the dependency-check block) is configured.
  * Scoped within `license` so a `dependencies`-shaped object elsewhere in the
  * file isn't mistaken for it.
- */
-const hasDependenciesBlock = async (tree) => {
-    if (!tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME))
-        return false;
-    const { matchGritQL } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
-    return matchGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`license: { $l }` where { $l <: contains `dependencies: $_` }');
+ */ const hasDependenciesBlock = async (tree)=>{
+    if (!tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) return false;
+    const { matchGritQL } = await import("../utils/ast.js");
+    return matchGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`license: { $l }` where { $l <: contains `dependencies: $_` }');
 };
 /**
  * Workspace-root npm-ecosystem lockfiles. Each is added to the license-check
  * cache inputs only when present, so the cache invalidates on dependency
  * changes without listing lockfiles for package managers the workspace doesn't
  * use.
- */
-const NPM_LOCKFILES = [
+ */ const NPM_LOCKFILES = [
     'pnpm-lock.yaml',
     'yarn.lock',
     'package-lock.json',
-    'bun.lockb',
+    'bun.lockb'
 ];
 /**
  * Recompute the `inputs` of the root `license-check` target from what's
@@ -213,16 +255,13 @@ const NPM_LOCKFILES = [
  * a uv workspace. Callers run this whenever they change the relevant state, so
  * the inputs stay correct regardless of generator order. No-op if the
  * license-check target doesn't exist yet.
- */
-const updateLicenseCheckTargetInputs = async (tree) => {
+ */ export const updateLicenseCheckTargetInputs = async (tree)=>{
     const rootProjectJsonPath = 'project.json';
-    if (!tree.exists(rootProjectJsonPath))
-        return;
+    if (!tree.exists(rootProjectJsonPath)) return;
     const rootProject = JSON.parse(tree.read(rootProjectJsonPath, 'utf-8'));
     const target = rootProject.targets?.['license-check'];
-    if (!target)
-        return;
-    const inputs = NPM_LOCKFILES.filter((f) => tree.exists(f)).map((f) => `{workspaceRoot}/${f}`);
+    if (!target) return;
+    const inputs = NPM_LOCKFILES.filter((f)=>tree.exists(f)).map((f)=>`{workspaceRoot}/${f}`);
     if (await hasPythonCollector(tree)) {
         inputs.push('{workspaceRoot}/**/uv.lock');
     }
@@ -230,25 +269,19 @@ const updateLicenseCheckTargetInputs = async (tree) => {
     target.inputs = inputs;
     tree.write(rootProjectJsonPath, JSON.stringify(rootProject, null, 2));
 };
-exports.updateLicenseCheckTargetInputs = updateLicenseCheckTargetInputs;
 /**
  * Whether the dependency check config has a `pythonCollector` configured.
- */
-const hasPythonCollector = async (tree) => {
-    if (!tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME))
-        return false;
-    const { matchGritQL } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
-    return matchGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`pythonCollector`');
+ */ const hasPythonCollector = async (tree)=>{
+    if (!tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) return false;
+    const { matchGritQL } = await import("../utils/ast.js");
+    return matchGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`pythonCollector`');
 };
 /**
  * The name of the project that owns the root `license-check` target, or
  * undefined if no project defines it.
- */
-const findLicenseCheckProjectName = (tree) => {
-    const { getProjects } = require('@nx/devkit');
-    for (const [name, config] of getProjects(tree)) {
-        if (config.targets?.['license-check'])
-            return name;
+ */ const findLicenseCheckProjectName = (tree)=>{
+    for (const [name, config] of getProjects(tree)){
+        if (config.targets?.['license-check']) return name;
     }
     return undefined;
 };
@@ -259,58 +292,47 @@ const findLicenseCheckProjectName = (tree) => {
  *
  * Callers format afterwards (generators call `formatFilesInSubtree` at the end),
  * so the rewritten project.json matches prettier.
- */
-const addLicenseCheckToLintTarget = (tree, projectName) => {
-    const { readProjectConfiguration, updateProjectConfiguration, } = require('@nx/devkit');
+ */ export const addLicenseCheckToLintTarget = (tree, projectName)=>{
     const licenseCheckProject = findLicenseCheckProjectName(tree);
-    if (!licenseCheckProject)
-        return;
+    if (!licenseCheckProject) return;
     let project;
     try {
         project = readProjectConfiguration(tree, projectName);
-    }
-    catch {
+    } catch  {
         return;
     }
     // Only wire projects that actually lint, and never the license-check project
     // itself (a target can't depend on its own project's target).
-    if (!project.targets?.lint || projectName === licenseCheckProject)
-        return;
-    (0, nx_1.addDependencyToTargetIfNotPresent)(project, 'lint', {
-        projects: [licenseCheckProject],
-        target: 'license-check',
+    if (!project.targets?.lint || projectName === licenseCheckProject) return;
+    addDependencyToTargetIfNotPresent(project, 'lint', {
+        projects: [
+            licenseCheckProject
+        ],
+        target: 'license-check'
     });
     updateProjectConfiguration(tree, projectName, project);
 };
-exports.addLicenseCheckToLintTarget = addLicenseCheckToLintTarget;
 /**
  * Wire every project's `lint` target to the root `license-check` target.
  * Called by the license generator so existing projects pick up the dependency
  * regardless of the order generators ran in.
- */
-const addLicenseCheckToAllLintTargets = (tree) => {
-    const { getProjects } = require('@nx/devkit');
-    for (const [name] of getProjects(tree)) {
-        (0, exports.addLicenseCheckToLintTarget)(tree, name);
+ */ export const addLicenseCheckToAllLintTargets = (tree)=>{
+    for (const [name] of getProjects(tree)){
+        addLicenseCheckToLintTarget(tree, name);
     }
 };
-exports.addLicenseCheckToAllLintTargets = addLicenseCheckToAllLintTargets;
 /**
  * Ensure the `dependencies` block (dependency license checking) exists within
  * the `license` config. If one already exists it is left untouched, so user
  * customizations survive.
- */
-const ensureDependencyCheckBlock = async (tree, options) => {
-    if (!tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME))
-        return;
-    const { addDestructuredImport } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
+ */ export const ensureDependencyCheckBlock = async (tree, options)=>{
+    if (!tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) return;
+    const { addDestructuredImport } = await import("../utils/ast.js");
     if (await hasDependenciesBlock(tree)) {
         return;
     }
     const withPython = options?.includeCollectors === 'npm+python';
-    const collectors = withPython
-        ? 'collectors: [npmCollector(), pythonCollector()]'
-        : 'collectors: [npmCollector()]';
+    const collectors = withPython ? 'collectors: [npmCollector(), pythonCollector()]' : 'collectors: [npmCollector()]';
     const block = `dependencies: { allow: DEFAULT_LICENSE_ALLOWLIST, ${collectors}, exceptions: [] }`;
     // Prepend the block as the first property of the license object. Prepending
     // (rather than `+=` appending) is comma-safe for every shape: GritQL's `+=`
@@ -320,13 +342,17 @@ const ensureDependencyCheckBlock = async (tree, options) => {
     // Only add the imports if the block was actually written (i.e. a license
     // object literal existed to attach it to).
     if (added) {
-        await addDestructuredImport(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, withPython
-            ? ['DEFAULT_LICENSE_ALLOWLIST', 'npmCollector', 'pythonCollector']
-            : ['DEFAULT_LICENSE_ALLOWLIST', 'npmCollector'], LICENSE_SDK_MODULE);
-        await (0, format_1.formatFilesInSubtree)(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME);
+        await addDestructuredImport(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, withPython ? [
+            'DEFAULT_LICENSE_ALLOWLIST',
+            'npmCollector',
+            'pythonCollector'
+        ] : [
+            'DEFAULT_LICENSE_ALLOWLIST',
+            'npmCollector'
+        ], LICENSE_SDK_MODULE);
+        await formatFilesInSubtree(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME);
     }
 };
-exports.ensureDependencyCheckBlock = ensureDependencyCheckBlock;
 /**
  * Ensure license exceptions are present in `license.dependencies.exceptions`.
  * An exception whose package is already listed is skipped (so existing reasons
@@ -335,132 +361,132 @@ exports.ensureDependencyCheckBlock = ensureDependencyCheckBlock;
  *
  * The `dependencies: { $scope }` scope keeps edits within the dependency-check
  * block, so an `exceptions` array elsewhere in the file isn't matched.
- */
-const ensureLicenseExceptions = async (tree, exceptions) => {
-    if (!tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME))
-        return;
-    const { insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
-    if (!(await hasDependenciesBlock(tree))) {
+ */ export const ensureLicenseExceptions = async (tree, exceptions)=>{
+    if (!tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) return;
+    const { insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await import("../utils/ast.js");
+    if (!await hasDependenciesBlock(tree)) {
         return;
     }
     let modified = false;
-    for (const exception of exceptions) {
+    for (const exception of exceptions){
         const pkg = JSON.stringify(exception.package);
-        const inserted = await insertViaGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`dependencies: { $scope }\` where {
+        const inserted = await insertViaGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`dependencies: { $scope }\` where {
         $scope <: not contains \`package: ${pkg}\`,
         ${appendToArray('exceptions', GRIT_INSERT_PLACEHOLDER)}
       }`, exceptionLiteral(exception));
         modified ||= inserted;
     }
     if (modified) {
-        await (0, format_1.formatFilesInSubtree)(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME);
+        await formatFilesInSubtree(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME);
     }
 };
-exports.ensureLicenseExceptions = ensureLicenseExceptions;
 /**
  * Add `pythonCollector()` to `license.dependencies.collectors`, unless one is
  * already configured.
- */
-const ensurePythonLicenseCollector = async (tree) => {
-    if (!tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME))
-        return;
-    const { addDestructuredImport, insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
-    if (!(await hasDependenciesBlock(tree))) {
+ */ export const ensurePythonLicenseCollector = async (tree)=>{
+    if (!tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) return;
+    const { addDestructuredImport, insertViaGritQL, GRIT_INSERT_PLACEHOLDER } = await import("../utils/ast.js");
+    if (!await hasDependenciesBlock(tree)) {
         return;
     }
-    const added = await insertViaGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`dependencies: { $scope }\` where {
+    const added = await insertViaGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, `\`dependencies: { $scope }\` where {
       $scope <: not contains \`pythonCollector\`,
       ${appendToArray('collectors', GRIT_INSERT_PLACEHOLDER)}
     }`, 'pythonCollector()');
     if (added) {
-        await addDestructuredImport(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, ['pythonCollector'], LICENSE_SDK_MODULE);
-        await (0, format_1.formatFilesInSubtree)(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME);
+        await addDestructuredImport(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, [
+            'pythonCollector'
+        ], LICENSE_SDK_MODULE);
+        await formatFilesInSubtree(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME);
         // Now that a Python collector is configured, ensure uv.lock is a cache
         // input. Runs here (not only in the license generator) so it's added
         // whenever the collector is — e.g. when py#project runs after license.
-        await (0, exports.updateLicenseCheckTargetInputs)(tree);
+        await updateLicenseCheckTargetInputs(tree);
     }
 };
-exports.ensurePythonLicenseCollector = ensurePythonLicenseCollector;
 /**
  * Build the default `license.source` config for a given license
- */
-const defaultLicenseConfig = (spdx, copyrightHolder) => {
-    switch (spdx) {
-        case 'ASL': {
-            // For ASL, we use a "box" style license header
-            const rawContent = [
-                `Copyright ${copyrightHolder}. All Rights Reserved.`,
-                '',
-                'Licensed under the Amazon Software License (the "License"). You may not use this file except in compliance',
-                'with the License. A copy of the License is located at',
-                '',
-                '   https://aws.amazon.com/asl/',
-                '',
-                'or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES',
-                'OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions',
-                'and limitations under the License.',
-            ];
-            const maxLen = Math.max(...rawContent.map((line) => line.length));
-            const lines = rawContent.map((line) => `${line}${' '.repeat(maxLen - line.length)}`);
-            return {
-                spdx,
-                copyrightHolder,
-                header: {
-                    content: { lines },
-                    format: {
-                        '**/*.{js,ts,jsx,tsx,mjs,mts}': {
-                            blockStart: `/***${'*'.repeat(maxLen)}**`,
-                            lineStart: ' *  ',
-                            lineEnd: ' *',
-                            blockEnd: ` ***${'*'.repeat(maxLen)}**/`,
+ */ export const defaultLicenseConfig = (spdx, copyrightHolder)=>{
+    switch(spdx){
+        case 'ASL':
+            {
+                // For ASL, we use a "box" style license header
+                const rawContent = [
+                    `Copyright ${copyrightHolder}. All Rights Reserved.`,
+                    '',
+                    'Licensed under the Amazon Software License (the "License"). You may not use this file except in compliance',
+                    'with the License. A copy of the License is located at',
+                    '',
+                    '   https://aws.amazon.com/asl/',
+                    '',
+                    'or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES',
+                    'OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions',
+                    'and limitations under the License.'
+                ];
+                const maxLen = Math.max(...rawContent.map((line)=>line.length));
+                const lines = rawContent.map((line)=>`${line}${' '.repeat(maxLen - line.length)}`);
+                return {
+                    spdx,
+                    copyrightHolder,
+                    header: {
+                        content: {
+                            lines
                         },
-                        '**/*.{py,sh,tf}': {
-                            blockStart: `###${'#'.repeat(maxLen)}##`,
-                            lineStart: '#  ',
-                            lineEnd: ' #',
-                            blockEnd: `###${'#'.repeat(maxLen)}##`,
+                        format: {
+                            '**/*.{js,ts,jsx,tsx,mjs,mts}': {
+                                blockStart: `/***${'*'.repeat(maxLen)}**`,
+                                lineStart: ' *  ',
+                                lineEnd: ' *',
+                                blockEnd: ` ***${'*'.repeat(maxLen)}**/`
+                            },
+                            '**/*.{py,sh,tf}': {
+                                blockStart: `###${'#'.repeat(maxLen)}##`,
+                                lineStart: '#  ',
+                                lineEnd: ' #',
+                                blockEnd: `###${'#'.repeat(maxLen)}##`
+                            }
                         },
-                    },
-                    exclude: ['**/*.gen.*'],
-                },
-            };
-        }
-        default: {
-            return {
-                spdx,
-                copyrightHolder,
-                ...(LICENSES_WITH_YEAR.has(spdx)
-                    ? {
-                        copyrightYear: new Date().getFullYear(),
+                        exclude: [
+                            '**/*.gen.*'
+                        ]
                     }
-                    : {}),
-                header: {
-                    content: {
-                        lines: [
-                            `Copyright ${copyrightHolder}. All Rights Reserved.`,
-                            `SPDX-License-Identifier: ${spdx}`,
-                        ],
-                    },
-                    format: {
-                        '**/*.{js,ts,jsx,tsx,mjs,mts}': {
-                            blockStart: '/**',
-                            lineStart: ' * ',
-                            blockEnd: ' */',
+                };
+            }
+        default:
+            {
+                return {
+                    spdx,
+                    copyrightHolder,
+                    ...LICENSES_WITH_YEAR.has(spdx) ? {
+                        copyrightYear: new Date().getFullYear()
+                    } : {},
+                    header: {
+                        content: {
+                            lines: [
+                                `Copyright ${copyrightHolder}. All Rights Reserved.`,
+                                `SPDX-License-Identifier: ${spdx}`
+                            ]
                         },
-                        '**/*.{py,sh,tf}': {
-                            blockStart: '#',
-                            lineStart: '# ',
-                            blockEnd: '#',
+                        format: {
+                            '**/*.{js,ts,jsx,tsx,mjs,mts}': {
+                                blockStart: '/**',
+                                lineStart: ' * ',
+                                blockEnd: ' */'
+                            },
+                            '**/*.{py,sh,tf}': {
+                                blockStart: '#',
+                                lineStart: '# ',
+                                blockEnd: '#'
+                            }
                         },
-                    },
-                    exclude: ['**/*.gen.*'],
-                },
-            };
-        }
+                        exclude: [
+                            '**/*.gen.*'
+                        ]
+                    }
+                };
+            }
     }
 };
-exports.defaultLicenseConfig = defaultLicenseConfig;
 /**
  * Write the `license.source` config (headers + LICENSE files) to the aws nx
  * plugin config.
@@ -469,30 +495,29 @@ exports.defaultLicenseConfig = defaultLicenseConfig;
  * block — a user-customized allowlist, collectors and exceptions — is
  * preserved, so re-running the license generator (e.g. to change the copyright
  * holder) never clobbers dependency-check customizations.
- */
-const writeLicenseConfig = async (tree, source) => {
-    const { captureGritQL } = await Promise.resolve().then(() => __importStar(require('../utils/ast')));
+ */ export const writeLicenseConfig = async (tree, source)=>{
+    const { captureGritQL } = await import("../utils/ast.js");
     // Capture the existing `dependencies: { ... }` block before overwriting the
     // license value, so we can re-attach it afterwards. It's managed by the
     // ensure* helpers, never written from here.
-    const preserved = tree.exists(utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME)
-        ? await captureGritQL(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`dependencies: $_`')
-        : undefined;
-    await (0, utils_1.updateAwsNxPluginConfig)(tree, { license: { source } });
+    const preserved = tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME) ? await captureGritQL(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME, '`dependencies: $_`') : undefined;
+    await updateAwsNxPluginConfig(tree, {
+        license: {
+            source
+        }
+    });
     // Re-attach the preserved block. The captured text may contain backticks,
     // `${...}` or quotes — prependLicenseProperty routes it through a placeholder
     // so it never enters the GritQL pattern.
     if (preserved) {
         await prependLicenseProperty(tree, preserved);
-        await (0, format_1.formatFilesInSubtree)(tree, utils_1.AWS_NX_PLUGIN_CONFIG_FILE_NAME);
+        await formatFilesInSubtree(tree, AWS_NX_PLUGIN_CONFIG_FILE_NAME);
     }
 };
-exports.writeLicenseConfig = writeLicenseConfig;
 /**
  * Read license configuration
- */
-const readLicenseConfig = async (tree) => {
-    return (await (0, utils_1.readAwsNxPluginConfig)(tree))?.license;
+ */ export const readLicenseConfig = async (tree)=>{
+    return readAwsNxPluginConfig(tree)?.license;
 };
-exports.readLicenseConfig = readLicenseConfig;
+
 //# sourceMappingURL=config.js.map