@composurecdk/eslint-plugin 0.10.0

package/dist/commonjs/rules/no-cdk-api-above-floor.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const imports_js_1 = require("./lib/imports.js");
+/**
+ * Foundational `isCfn*` guards that predate the floor (core, since v2.0) and
+ * are therefore allowed — `isCfnResource` is in fact the portable replacement
+ * for the banned per-resource guards.
+ */
+const ALLOWED_CFN_GUARDS = new Set(["isCfnResource", "isCfnElement"]);
+/**
+ * The ban list. Add an entry whenever an `aws-cdk-lib` API we reach for turns
+ * out to postdate the supported floor — this list is expected to grow as the
+ * floor is pinned and lowered ahead of 1.0.0.
+ *
+ * Seeded with the per-resource `isCfn<Resource>` static type guards, which
+ * aws-cdk-lib first shipped on every generated L1 in 2.231.0 (verified by
+ * installing real versions: 2.230.0 lacks them, 2.231.0 has them). Calling
+ * them (e.g. `CfnAlarm.isCfnAlarm(node)`) throws `TypeError` on the older
+ * versions in our `^2` peer range — see issue #146.
+ */
+const FORBIDDEN = [
+    {
+        matches: (name) => /^isCfn[A-Z]/.test(name) && !ALLOWED_CFN_GUARDS.has(name),
+        label: "the per-resource `Cfn<Resource>.isCfn<Resource>` L1 static type guards",
+        since: "2.231.0",
+        use: "`CfnResource.isCfnResource(x) && x.cfnResourceType === Cfn<Resource>.CFN_RESOURCE_TYPE_NAME` " +
+            "(what the static does internally, but valid across the whole peer range), e.g. the " +
+            "`isCfnAlarm` helper in @composurecdk/cloudwatch",
+    },
+];
+/**
+ * Flags an `aws-cdk-lib` API newer than the oldest CDK version this package
+ * supports.
+ *
+ * Such a call type-checks and passes tests, because both run against whichever
+ * CDK is installed here — the newest. It then throws at runtime for anyone whose
+ * own `aws-cdk-lib` is older, while still inside the range the package declares
+ * it supports. The fix is a form of the same check that works across the whole
+ * range; the rule's message names one per banned API.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-cdk-api-above-floor.md | the rule documentation}.
+ */
+exports.rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban aws-cdk-lib APIs newer than the supported peer-dependency floor",
+        },
+        schema: [],
+        messages: {
+            aboveFloor: "{{label}} were added in aws-cdk-lib {{since}}, above the supported floor — they throw on " +
+                "older versions in the peer range. Use {{use}}.",
+        },
+    },
+    create(ctx) {
+        return {
+            MemberExpression(node) {
+                if (node.property.type !== "Identifier")
+                    return;
+                const property = node.property;
+                const root = (0, imports_js_1.chainRoot)(node.object);
+                if (root === undefined)
+                    return;
+                const source = (0, imports_js_1.importSourceOf)(ctx.sourceCode.getScope(node), root.name);
+                if (source === undefined || !(0, imports_js_1.isCdkSource)(source))
+                    return;
+                const forbidden = FORBIDDEN.find((entry) => entry.matches(property.name));
+                if (forbidden === undefined)
+                    return;
+                ctx.report({
+                    node: property,
+                    messageId: "aboveFloor",
+                    data: { label: forbidden.label, since: forbidden.since, use: forbidden.use },
+                });
+            },
+        };
+    },
+};
+//# sourceMappingURL=no-cdk-api-above-floor.js.map

package/dist/commonjs/rules/no-cdk-api-above-floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-cdk-api-above-floor.js","sourceRoot":"","sources":["../../../src/rules/no-cdk-api-above-floor.ts"],"names":[],"mappings":";;;AAEA,iDAA0E;AAqB1E;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,MAAM,SAAS,GAAsB;IACnC;QACE,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC;QAC5E,KAAK,EAAE,wEAAwE;QAC/E,KAAK,EAAE,SAAS;QAChB,GAAG,EACD,+FAA+F;YAC/F,qFAAqF;YACrF,iDAAiD;KACpD;CACF,CAAC;AAEF;;;;;;;;;;;GAWG;AACU,QAAA,IAAI,GAAoB;IACnC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,qEAAqE;SACnF;QACD,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR,UAAU,EACR,2FAA2F;gBAC3F,gDAAgD;SACnD;KACF;IACD,MAAM,CAAC,GAAG;QACR,OAAO;YACL,gBAAgB,CAAC,IAAsB;gBACrC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;oBAAE,OAAO;gBAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;gBAC/B,MAAM,IAAI,GAAG,IAAA,sBAAS,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACpC,IAAI,IAAI,KAAK,SAAS;oBAAE,OAAO;gBAC/B,MAAM,MAAM,GAAG,IAAA,2BAAc,EAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxE,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,IAAA,wBAAW,EAAC,MAAM,CAAC;oBAAE,OAAO;gBAEzD,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC1E,IAAI,SAAS,KAAK,SAAS;oBAAE,OAAO;gBACpC,GAAG,CAAC,MAAM,CAAC;oBACT,IAAI,EAAE,QAAQ;oBACd,SAAS,EAAE,YAAY;oBACvB,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE;iBAC7E,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/commonjs/rules/no-cjs-incompatible-syntax.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "eslint";
+/**
+ * Flags syntax with no CommonJS equivalent: `import.meta`, top-level `await` and
+ * top-level `for await…of`.
+ *
+ * These packages are published as both ECMAScript and CommonJS modules from one
+ * source. All three constructs are valid ESM that the CommonJS compile cannot
+ * emit, so each one breaks half the build. Reporting them as you type beats
+ * discovering it when the second dialect compiles.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-cjs-incompatible-syntax.md | the rule documentation}.
+ */
+export declare const rule: Rule.RuleModule;
+//# sourceMappingURL=no-cjs-incompatible-syntax.d.ts.map

package/dist/commonjs/rules/no-cjs-incompatible-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-cjs-incompatible-syntax.d.ts","sourceRoot":"","sources":["../../../src/rules/no-cjs-incompatible-syntax.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AASnC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,UAuCvB,CAAC"}

package/dist/commonjs/rules/no-cjs-incompatible-syntax.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const FUNCTION_TYPES = new Set([
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "ArrowFunctionExpression",
+]);
+/**
+ * Flags syntax with no CommonJS equivalent: `import.meta`, top-level `await` and
+ * top-level `for await…of`.
+ *
+ * These packages are published as both ECMAScript and CommonJS modules from one
+ * source. All three constructs are valid ESM that the CommonJS compile cannot
+ * emit, so each one breaks half the build. Reporting them as you type beats
+ * discovering it when the second dialect compiles.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-cjs-incompatible-syntax.md | the rule documentation}.
+ */
+exports.rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban ESM-only syntax (import.meta, top-level await) that cannot emit to CommonJS",
+        },
+        schema: [],
+        messages: {
+            importMeta: "`import.meta` has no CommonJS equivalent, so it breaks the CommonJS half of a " +
+                "dual-published build. Take the value from a parameter or a caller instead.",
+            topLevelAwait: "Top-level `await` has no CommonJS equivalent, so it breaks the CommonJS half of a " +
+                "dual-published build. Move the `await` inside an async function.",
+        },
+    },
+    create(ctx) {
+        const isTopLevel = (node) => !ctx.sourceCode.getAncestors(node).some((ancestor) => FUNCTION_TYPES.has(ancestor.type));
+        return {
+            MetaProperty(node) {
+                if (node.meta.name === "import" && node.property.name === "meta") {
+                    ctx.report({ node, messageId: "importMeta" });
+                }
+            },
+            AwaitExpression(node) {
+                if (isTopLevel(node)) {
+                    ctx.report({ node, messageId: "topLevelAwait" });
+                }
+            },
+            "ForOfStatement[await=true]"(node) {
+                if (isTopLevel(node)) {
+                    ctx.report({ node, messageId: "topLevelAwait" });
+                }
+            },
+        };
+    },
+};
+//# sourceMappingURL=no-cjs-incompatible-syntax.js.map

package/dist/commonjs/rules/no-cjs-incompatible-syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-cjs-incompatible-syntax.js","sourceRoot":"","sources":["../../../src/rules/no-cjs-incompatible-syntax.ts"],"names":[],"mappings":";;;AAGA,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;IAC7B,qBAAqB;IACrB,oBAAoB;IACpB,yBAAyB;CAC1B,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACU,QAAA,IAAI,GAAoB;IACnC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EACT,iFAAiF;SACpF;QACD,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR,UAAU,EACR,gFAAgF;gBAChF,4EAA4E;YAC9E,aAAa,EACX,oFAAoF;gBACpF,kEAAkE;SACrE;KACF;IACD,MAAM,CAAC,GAAG;QACR,MAAM,UAAU,GAAG,CAAC,IAAU,EAAW,EAAE,CACzC,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAE3F,OAAO;YACL,YAAY,CAAC,IAAkB;gBAC7B,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBACjE,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;YACD,eAAe,CAAC,IAAqB;gBACnC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;oBACrB,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC;YACD,4BAA4B,CAAC,IAAoB;gBAC/C,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;oBACrB,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/commonjs/rules/no-realm-bound-instanceof.d.ts

@@ -0,0 +1,25 @@
+import type { Rule } from "eslint";
+/**
+ * Bans `instanceof` against a class reached through an `import`.
+ *
+ * These packages ship as both ECMAScript and CommonJS modules, and both copies
+ * can load in the same process — a consumer importing one while a dependency
+ * requires the other. Each copy evaluates its own class objects, so an instance
+ * created by one fails `instanceof` against the other's class: the check returns
+ * `false` for a value that is plainly of that type.
+ *
+ * It fails silently, which is what makes it dangerous — a deduplication quietly
+ * skipped, a guard quietly bypassed, and no error to trace. Use a `Symbol.for(…)`
+ * brand instead, which is shared across copies.
+ *
+ * A relative import is no safer by default: it resolves separately in each copy.
+ * A package nothing can install twice may say so with
+ * `assumeNeverInstalledAsADependency`, which treats its own modules as
+ * same-realm while still flagging dependencies. An application is the archetype;
+ * being private is not enough, since a private package can still be a
+ * dependency.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-realm-bound-instanceof.md | the rule documentation}.
+ */
+export declare const rule: Rule.RuleModule;
+//# sourceMappingURL=no-realm-bound-instanceof.d.ts.map

package/dist/commonjs/rules/no-realm-bound-instanceof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-realm-bound-instanceof.d.ts","sourceRoot":"","sources":["../../../src/rules/no-realm-bound-instanceof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,UA8EvB,CAAC"}

package/dist/commonjs/rules/no-realm-bound-instanceof.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const imports_js_1 = require("./lib/imports.js");
+/**
+ * Bans `instanceof` against a class reached through an `import`.
+ *
+ * These packages ship as both ECMAScript and CommonJS modules, and both copies
+ * can load in the same process — a consumer importing one while a dependency
+ * requires the other. Each copy evaluates its own class objects, so an instance
+ * created by one fails `instanceof` against the other's class: the check returns
+ * `false` for a value that is plainly of that type.
+ *
+ * It fails silently, which is what makes it dangerous — a deduplication quietly
+ * skipped, a guard quietly bypassed, and no error to trace. Use a `Symbol.for(…)`
+ * brand instead, which is shared across copies.
+ *
+ * A relative import is no safer by default: it resolves separately in each copy.
+ * A package nothing can install twice may say so with
+ * `assumeNeverInstalledAsADependency`, which treats its own modules as
+ * same-realm while still flagging dependencies. An application is the archetype;
+ * being private is not enough, since a private package can still be a
+ * dependency.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-realm-bound-instanceof.md | the rule documentation}.
+ */
+exports.rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban realm-bound `instanceof` against imported classes",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    assumeNeverInstalledAsADependency: {
+                        type: "boolean",
+                        description: "Exempt this package's own relative imports, on the basis that nothing can " +
+                            "install it twice. An application's claim to make; a library must not, since a " +
+                            "consumer can install two versions of it side by side.",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            cdkClass: "`instanceof {{name}}` is realm-bound: it returns false for a value created by another " +
+                "copy of `aws-cdk-lib`. Identify the construct by its L1 instead — " +
+                "`CfnResource.isCfnResource(x) && x.cfnResourceType === Cfn{{name}}.CFN_RESOURCE_TYPE_NAME`.",
+            ownClass: "`instanceof {{name}}` is realm-bound: `{{source}}` resolves separately in each copy of " +
+                "this package, so the check returns false for a value that is plainly of that type. " +
+                "Brand the class with `Symbol.for(...)` and test for that brand instead.",
+            dependencyClass: "`instanceof {{name}}` is realm-bound: `{{source}}` can load twice in one process, so the " +
+                "check returns false for a value that is plainly of that type. Prefer a type guard the " +
+                "package provides, or test a distinguishing property rather than identity. If the class " +
+                "is one you own, brand it with `Symbol.for(...)`.",
+        },
+    },
+    create(ctx) {
+        const { assumeNeverInstalledAsADependency = false } = (ctx.options[0] ?? {});
+        return {
+            BinaryExpression(node) {
+                if (node.operator !== "instanceof")
+                    return;
+                const root = (0, imports_js_1.chainRoot)(node.right);
+                if (root === undefined)
+                    return;
+                const source = (0, imports_js_1.importSourceOf)(ctx.sourceCode.getScope(node), root.name);
+                if (source === undefined)
+                    return;
+                // A relative specifier resolves inside this package, so it duplicates
+                // only if the package itself does. Deliberately not `#` subpaths: the
+                // `imports` field can map one to an external package.
+                if (assumeNeverInstalledAsADependency && source.startsWith("."))
+                    return;
+                // Name the class, not the namespace it was reached through:
+                // `cdk.aws_s3.Bucket` is "Bucket", and the cdk message interpolates
+                // that into `Cfn<name>.CFN_RESOURCE_TYPE_NAME`.
+                const target = (0, imports_js_1.unwrapWrappers)(node.right);
+                const name = target.type === "MemberExpression" && target.property.type === "Identifier"
+                    ? target.property.name
+                    : root.name;
+                // Report on the class reference, not the whole expression: the fix
+                // replaces the right-hand side, and a narrow squiggle points at it.
+                // The specifier says whether the reader can brand the class: a relative
+                // import is their own module, anything else is someone else's package.
+                const messageId = (0, imports_js_1.isCdkSource)(source)
+                    ? "cdkClass"
+                    : source.startsWith(".")
+                        ? "ownClass"
+                        : "dependencyClass";
+                ctx.report({ node: node.right, messageId, data: { name, source } });
+            },
+        };
+    },
+};
+//# sourceMappingURL=no-realm-bound-instanceof.js.map

package/dist/commonjs/rules/no-realm-bound-instanceof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-realm-bound-instanceof.js","sourceRoot":"","sources":["../../../src/rules/no-realm-bound-instanceof.ts"],"names":[],"mappings":";;;AAEA,iDAA0F;AAE1F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,IAAI,GAAoB;IACnC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,uDAAuD;SACrE;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,iCAAiC,EAAE;wBACjC,IAAI,EAAE,SAAS;wBACf,WAAW,EACT,4EAA4E;4BAC5E,gFAAgF;4BAChF,uDAAuD;qBAC1D;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,QAAQ,EAAE;YACR,QAAQ,EACN,wFAAwF;gBACxF,oEAAoE;gBACpE,6FAA6F;YAC/F,QAAQ,EACN,yFAAyF;gBACzF,qFAAqF;gBACrF,yEAAyE;YAC3E,eAAe,EACb,2FAA2F;gBAC3F,wFAAwF;gBACxF,yFAAyF;gBACzF,kDAAkD;SACrD;KACF;IACD,MAAM,CAAC,GAAG;QACR,MAAM,EAAE,iCAAiC,GAAG,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAE1E,CAAC;QAEF,OAAO;YACL,gBAAgB,CAAC,IAAsB;gBACrC,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY;oBAAE,OAAO;gBAC3C,MAAM,IAAI,GAAG,IAAA,sBAAS,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACnC,IAAI,IAAI,KAAK,SAAS;oBAAE,OAAO;gBAE/B,MAAM,MAAM,GAAG,IAAA,2BAAc,EAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxE,IAAI,MAAM,KAAK,SAAS;oBAAE,OAAO;gBACjC,sEAAsE;gBACtE,sEAAsE;gBACtE,sDAAsD;gBACtD,IAAI,iCAAiC,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;oBAAE,OAAO;gBAExE,4DAA4D;gBAC5D,oEAAoE;gBACpE,gDAAgD;gBAChD,MAAM,MAAM,GAAG,IAAA,2BAAc,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1C,MAAM,IAAI,GACR,MAAM,CAAC,IAAI,KAAK,kBAAkB,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;oBACzE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI;oBACtB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;gBAEhB,mEAAmE;gBACnE,oEAAoE;gBACpE,wEAAwE;gBACxE,uEAAuE;gBACvE,MAAM,SAAS,GAAG,IAAA,wBAAW,EAAC,MAAM,CAAC;oBACnC,CAAC,CAAC,UAAU;oBACZ,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;wBACtB,CAAC,CAAC,UAAU;wBACZ,CAAC,CAAC,iBAAiB,CAAC;gBAExB,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;YACtE,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/commonjs/rules/no-typescript-private-modifier.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from "eslint";
+/**
+ * Bans the TypeScript `private` modifier in favour of ECMAScript private fields.
+ *
+ * The two are not interchangeable once a class is generic over its own members.
+ * A TypeScript `private` member is still part of the type, so it appears in
+ * `keyof T`, survives into a mapped type, and reaches the emitted `.d.ts` — where
+ * a consumer's compiler cannot name it and reports TS4094. A `#field` is not
+ * part of the type at all, so it never gets that far.
+ *
+ * A private constructor stays allowed: `#constructor` is not valid syntax, so
+ * there is nothing to prefer over it.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-typescript-private-modifier.md | the rule documentation}.
+ */
+export declare const rule: Rule.RuleModule;
+//# sourceMappingURL=no-typescript-private-modifier.d.ts.map

package/dist/commonjs/rules/no-typescript-private-modifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-typescript-private-modifier.d.ts","sourceRoot":"","sources":["../../../src/rules/no-typescript-private-modifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAkCnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,UAwDvB,CAAC"}

package/dist/commonjs/rules/no-typescript-private-modifier.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+/**
+ * The member's own name, for the message. A computed key has no name to give —
+ * `#[expr]` is not a thing — so the message falls back to a placeholder rather
+ * than naming whatever expression produced the key.
+ */
+function memberName(key, computed) {
+    if (computed)
+        return "field";
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type === "Literal" && typeof key.value === "string")
+        return key.value;
+    return "field";
+}
+/** The bound name of a parameter, seeing through a default value. */
+function parameterName(parameter) {
+    const bound = parameter.type === "AssignmentPattern" ? parameter.left : parameter;
+    return bound.type === "Identifier" ? bound.name : "field";
+}
+/**
+ * Bans the TypeScript `private` modifier in favour of ECMAScript private fields.
+ *
+ * The two are not interchangeable once a class is generic over its own members.
+ * A TypeScript `private` member is still part of the type, so it appears in
+ * `keyof T`, survives into a mapped type, and reaches the emitted `.d.ts` — where
+ * a consumer's compiler cannot name it and reports TS4094. A `#field` is not
+ * part of the type at all, so it never gets that far.
+ *
+ * A private constructor stays allowed: `#constructor` is not valid syntax, so
+ * there is nothing to prefer over it.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/no-typescript-private-modifier.md | the rule documentation}.
+ */
+exports.rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban the TypeScript `private` modifier in favour of ECMAScript `#` fields",
+        },
+        schema: [],
+        messages: {
+            property: "Use an ECMAScript private field (`#{{name}}`) instead of the TypeScript `private` " +
+                "modifier. A `private` member still appears in `keyof T` and is carried through mapped " +
+                "types into the emitted .d.ts, where it produces TS4094 for consumers.",
+            method: "Use an ECMAScript private method (`#{{name}}()`) instead of the TypeScript `private` " +
+                "modifier. A private constructor is the only permitted use, since `#constructor` is not " +
+                "valid syntax.",
+            parameterProperty: "A parameter property cannot be ECMAScript private. Declare the field as " +
+                "`readonly #{{name}}` and assign it in the constructor body.",
+        },
+    },
+    create(ctx) {
+        // Each handler reports on the member's own name rather than the whole
+        // declaration: the fix replaces the modifier and renames the key, so a
+        // narrow squiggle points at both.
+        return {
+            "PropertyDefinition[accessibility='private']"(node) {
+                ctx.report({
+                    node: node.key,
+                    messageId: "property",
+                    data: { name: memberName(node.key, node.computed) },
+                });
+            },
+            "MethodDefinition[accessibility='private'][kind!='constructor']"(node) {
+                ctx.report({
+                    node: node.key,
+                    messageId: "method",
+                    data: { name: memberName(node.key, node.computed) },
+                });
+            },
+            // `accessor x` is a distinct node from a plain field, and its `private`
+            // reaches `keyof T` the same way.
+            "AccessorProperty[accessibility='private']"(node) {
+                const { key, computed } = node;
+                ctx.report({ node: key, messageId: "property", data: { name: memberName(key, computed) } });
+            },
+            "TSParameterProperty[accessibility='private']"(node) {
+                const { parameter } = node;
+                ctx.report({
+                    node: parameter,
+                    messageId: "parameterProperty",
+                    data: { name: parameterName(parameter) },
+                });
+            },
+        };
+    },
+};
+//# sourceMappingURL=no-typescript-private-modifier.js.map

package/dist/commonjs/rules/no-typescript-private-modifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-typescript-private-modifier.js","sourceRoot":"","sources":["../../../src/rules/no-typescript-private-modifier.ts"],"names":[],"mappings":";;;AAgBA;;;;GAIG;AACH,SAAS,UAAU,CAAC,GAAS,EAAE,QAAiB;IAC9C,IAAI,QAAQ;QAAE,OAAO,OAAO,CAAC;IAC7B,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC;IAC/C,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC,KAAK,CAAC;IAC9E,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,qEAAqE;AACrE,SAAS,aAAa,CAAC,SAAe;IACpC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,KAAK,mBAAmB,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IAClF,OAAO,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;GAaG;AACU,QAAA,IAAI,GAAoB;IACnC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,0EAA0E;SACxF;QACD,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR,QAAQ,EACN,oFAAoF;gBACpF,wFAAwF;gBACxF,uEAAuE;YACzE,MAAM,EACJ,uFAAuF;gBACvF,yFAAyF;gBACzF,eAAe;YACjB,iBAAiB,EACf,0EAA0E;gBAC1E,6DAA6D;SAChE;KACF;IACD,MAAM,CAAC,GAAG;QACR,sEAAsE;QACtE,uEAAuE;QACvE,kCAAkC;QAClC,OAAO;YACL,6CAA6C,CAAC,IAAwB;gBACpE,GAAG,CAAC,MAAM,CAAC;oBACT,IAAI,EAAE,IAAI,CAAC,GAAG;oBACd,SAAS,EAAE,UAAU;oBACrB,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE;iBACpD,CAAC,CAAC;YACL,CAAC;YACD,gEAAgE,CAAC,IAAsB;gBACrF,GAAG,CAAC,MAAM,CAAC;oBACT,IAAI,EAAE,IAAI,CAAC,GAAG;oBACd,SAAS,EAAE,QAAQ;oBACnB,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE;iBACpD,CAAC,CAAC;YACL,CAAC;YACD,wEAAwE;YACxE,kCAAkC;YAClC,2CAA2C,CAAC,IAAU;gBACpD,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAuC,CAAC;gBAClE,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;YAC9F,CAAC;YACD,8CAA8C,CAAC,IAAU;gBACvD,MAAM,EAAE,SAAS,EAAE,GAAG,IAAwC,CAAC;gBAC/D,GAAG,CAAC,MAAM,CAAC;oBACT,IAAI,EAAE,SAAS;oBACf,SAAS,EAAE,mBAAmB;oBAC9B,IAAI,EAAE,EAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE;iBACzC,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/commonjs/rules/redeclared-prop-must-track-cdk-type.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from "eslint";
+/**
+ * Flags a re-declared CDK prop that pins a named CDK interface inside
+ * `Resolvable<…>` rather than reading the type from CDK's own prop.
+ *
+ * A builder's props type is CDK's props type with a few keys lifted out and
+ * re-declared. Everything left inside the `Omit` keeps tracking whichever
+ * `aws-cdk-lib` the consumer installed; a key re-spelled with a named interface
+ * stops tracking it, freezing at whatever that interface meant when it was
+ * written. When CDK later widens that prop, the builder goes on rejecting values
+ * the construct it wraps now accepts — and it surfaces in the consumer's own
+ * compile, not in this package's.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/redeclared-prop-must-track-cdk-type.md | the rule documentation}.
+ */
+export declare const rule: Rule.RuleModule;
+//# sourceMappingURL=redeclared-prop-must-track-cdk-type.d.ts.map

package/dist/commonjs/rules/redeclared-prop-must-track-cdk-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redeclared-prop-must-track-cdk-type.d.ts","sourceRoot":"","sources":["../../../src/rules/redeclared-prop-must-track-cdk-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAqFnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,UAiEvB,CAAC"}

package/dist/commonjs/rules/redeclared-prop-must-track-cdk-type.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const imports_js_1 = require("./lib/imports.js");
+/** True for `@aws-cdk/aws-*-alpha` and friends, alongside `aws-cdk-lib`. */
+function isCdkModule(source) {
+    return (0, imports_js_1.isCdkSource)(source) || source.startsWith("@aws-cdk/");
+}
+/** The first type argument of a type reference or interface heritage, either spelling. */
+function typeArgAt(node, index) {
+    const args = (node.typeArguments ?? node.typeParameters);
+    const params = args?.params ?? [];
+    return params.at(index);
+}
+/** The leftmost identifier of `Foo` or `ns.Foo`, or `undefined` for anything else. */
+function rootName(typeName) {
+    let current = typeName;
+    while (current.type === "TSQualifiedName")
+        current = current.left;
+    return current.type === "Identifier" ? current.name : undefined;
+}
+/** The string keys named by `Omit`'s second argument, ignoring non-literal ones. */
+function literalKeys(node) {
+    if (node === undefined)
+        return [];
+    if (node.type === "TSUnionType") {
+        return node.types.flatMap((t) => literalKeys(t));
+    }
+    if (node.type !== "TSLiteralType")
+        return [];
+    const literal = node.literal;
+    return typeof literal.value === "string" ? [literal.value] : [];
+}
+/** The keys an interface's `extends` clause omits from a base CDK props type. */
+function omittedKeys(heritage) {
+    const keys = new Set();
+    for (const entry of heritage) {
+        const expression = entry.expression;
+        if (expression?.type !== "Identifier" || expression.name !== "Omit")
+            continue;
+        for (const key of literalKeys(typeArgAt(entry, 1)))
+            keys.add(key);
+    }
+    return keys;
+}
+/** Every `Resolvable<…>` reference nested anywhere inside a type annotation. */
+function resolvableRefs(node, found = []) {
+    if (node === null || typeof node !== "object" || !("type" in node))
+        return found;
+    const typed = node;
+    if (typed.type === "TSTypeReference" && rootName(typed.typeName) === "Resolvable") {
+        found.push(typed);
+    }
+    for (const [key, value] of Object.entries(typed)) {
+        // `parent` points back up the tree — following it never terminates.
+        if (key === "parent")
+            continue;
+        if (Array.isArray(value))
+            for (const item of value)
+                resolvableRefs(item, found);
+        else
+            resolvableRefs(value, found);
+    }
+    return found;
+}
+/** The property name of a `key: T` signature, or `undefined` for a computed one. */
+function propertyName(member) {
+    if (member.type !== "TSPropertySignature" || member.computed === true)
+        return undefined;
+    const key = member.key;
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type === "Literal" && typeof key.value === "string")
+        return key.value;
+    return undefined;
+}
+/**
+ * Flags a re-declared CDK prop that pins a named CDK interface inside
+ * `Resolvable<…>` rather than reading the type from CDK's own prop.
+ *
+ * A builder's props type is CDK's props type with a few keys lifted out and
+ * re-declared. Everything left inside the `Omit` keeps tracking whichever
+ * `aws-cdk-lib` the consumer installed; a key re-spelled with a named interface
+ * stops tracking it, freezing at whatever that interface meant when it was
+ * written. When CDK later widens that prop, the builder goes on rejecting values
+ * the construct it wraps now accepts — and it surfaces in the consumer's own
+ * compile, not in this package's.
+ *
+ * See {@link https://github.com/laazyj/composureCDK/blob/main/packages/eslint-plugin/docs/rules/redeclared-prop-must-track-cdk-type.md | the rule documentation}.
+ */
+exports.rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "A re-declared CDK prop must read its type from CDK's own prop, not pin an interface",
+        },
+        schema: [],
+        messages: {
+            pinnedType: "`{{prop}}` re-declares a prop omitted from `{{base}}`, but pins `{{pinned}}` — the " +
+                "builder stops accepting what CDK accepts as soon as CDK widens the prop. Read the type " +
+                'from CDK\'s own prop instead: `Resolvable<NonNullable<{{base}}["{{prop}}"]>>`. ' +
+                "Keep the indexed access inline — extracting it to a named alias puts an unnameable " +
+                "type into the emitted declaration.",
+        },
+    },
+    create(ctx) {
+        const cdkTypeNames = new Set();
+        const listener = {
+            ImportDeclaration(node) {
+                if (typeof node.source.value !== "string" || !isCdkModule(node.source.value))
+                    return;
+                for (const spec of node.specifiers) {
+                    cdkTypeNames.add(spec.local.name);
+                }
+            },
+        };
+        listener.TSInterfaceDeclaration = (node) => {
+            const decl = node;
+            const heritage = decl.extends ?? [];
+            const omitted = omittedKeys(heritage);
+            if (omitted.size === 0)
+                return;
+            // Name the base the indexed access should read from — the first `Omit`'s
+            // own base, which is the CDK props type in every builder that has one.
+            const omit = heritage.find((entry) => entry.expression?.name === "Omit");
+            const omitBase = omit === undefined ? undefined : typeArgAt(omit, 0);
+            const base = (omitBase === undefined ? undefined : rootName(omitBase.typeName)) ??
+                "CdkProps";
+            const body = decl.body?.body ?? [];
+            for (const member of body) {
+                const prop = propertyName(member);
+                if (prop === undefined || !omitted.has(prop))
+                    continue;
+                for (const resolvable of resolvableRefs(member.typeAnnotation)) {
+                    const inner = typeArgAt(resolvable, 0);
+                    if (inner?.type !== "TSTypeReference")
+                        continue;
+                    const pinned = rootName(inner.typeName);
+                    if (pinned === undefined || !cdkTypeNames.has(pinned))
+                        continue;
+                    ctx.report({
+                        node: inner,
+                        messageId: "pinnedType",
+                        data: { prop, base, pinned },
+                    });
+                }
+            }
+        };
+        return listener;
+    },
+};
+//# sourceMappingURL=redeclared-prop-must-track-cdk-type.js.map

package/dist/commonjs/rules/redeclared-prop-must-track-cdk-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redeclared-prop-must-track-cdk-type.js","sourceRoot":"","sources":["../../../src/rules/redeclared-prop-must-track-cdk-type.ts"],"names":[],"mappings":"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"}

package/dist/esm/configs/presets.d.ts

@@ -0,0 +1,42 @@
+import type { Linter } from "eslint";
+/**
+ * The rule sets behind each preset, grouped by **what must be true of the
+ * consumer** for the rule to be correct — not by subject matter. Every rule
+ * belongs to exactly one, which a test enforces.
+ *
+ * The reasoning behind the tiers, and what moving a rule between them costs,
+ * is in ADR-0019.
+ */
+/**
+ * True for anyone writing a `Lifecycle` or a builder, in any shape of project —
+ * an application as much as a library.
+ */
+export declare const recommendedRules: Linter.RulesRecord;
+/**
+ * Additionally true for a package other people compile against.
+ *
+ * Each hazard here exists only once you emit a `.d.ts` someone else consumes:
+ * TS4094 and TS2883 need an exported mapped type, and a narrowed prop type only
+ * hurts when it is your published API. An application emits none of that.
+ *
+ * `lifecycle-build-must-forward-context` sits here for a different reason — a
+ * root-level build has no context to forward and is correct, and in an
+ * application nearly every build is a root build. That is a property of where
+ * the call sits in the composition graph, so no amount of narrowing the rule
+ * fixes it.
+ */
+export declare const libraryAuthorRules: Linter.RulesRecord;
+/**
+ * Additionally true for a package shipping both an ESM and a CommonJS build.
+ * Out of `recommended` because banning `import.meta` is a false positive for an
+ * ESM-only library, where it is legal and idiomatic.
+ */
+export declare const dualPublishingRules: Linter.RulesRecord;
+/**
+ * composureCDK's own house rules. Each encodes a convention or a hardcoded
+ * value — this repo's CDK floor, its tagging wrapper, its constraint catalogue
+ * — that is wrong elsewhere. Published so the preset is reproducible, not as a
+ * recommendation.
+ */
+export declare const internalRules: Linter.RulesRecord;
+//# sourceMappingURL=presets.d.ts.map