jsii 5.4.16-dev.2 → 5.4.16-dev.3

package/lib/tsconfig/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptConfigValidationRuleSet = void 0;
+var TypeScriptConfigValidationRuleSet;
+(function (TypeScriptConfigValidationRuleSet) {
+    TypeScriptConfigValidationRuleSet["STRICT"] = "strict";
+    TypeScriptConfigValidationRuleSet["GENERATED"] = "generated";
+    TypeScriptConfigValidationRuleSet["MINIMAL"] = "minimal";
+    TypeScriptConfigValidationRuleSet["NONE"] = "off";
+})(TypeScriptConfigValidationRuleSet || (exports.TypeScriptConfigValidationRuleSet = TypeScriptConfigValidationRuleSet = {}));
+//# sourceMappingURL=index.js.map

package/lib/tsconfig/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tsconfig/index.ts"],"names":[],"mappings":";;;AAaA,IAAY,iCAKX;AALD,WAAY,iCAAiC;IAC3C,sDAAiB,CAAA;IACjB,4DAAuB,CAAA;IACvB,wDAAmB,CAAA;IACnB,iDAAY,CAAA;AACd,CAAC,EALW,iCAAiC,iDAAjC,iCAAiC,QAK5C","sourcesContent":["import * as ts from 'typescript';\n\nexport interface TypeScriptConfig {\n  files?: string[];\n  extends?: string | string[];\n  include?: string[];\n  exclude?: string[];\n  references?: ts.ProjectReference[];\n  compilerOptions: ts.CompilerOptions;\n  watchOptions?: ts.WatchOptions;\n  typeAcquisition?: ts.TypeAcquisition;\n}\n\nexport enum TypeScriptConfigValidationRuleSet {\n  STRICT = 'strict',\n  GENERATED = 'generated',\n  MINIMAL = 'minimal',\n  NONE = 'off',\n}\n"]}

package/lib/tsconfig/rulesets/configurable.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from '../validator';
+declare const configurable: RuleSet;
+export default configurable;
+//# sourceMappingURL=configurable.d.ts.map

package/lib/tsconfig/rulesets/configurable.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+// A rule set defining all compilerOptions that can be configured by users with or without constraints.
+// This is an internal rule set, that may be used by other rule sets.
+// Settings previously configurable via the jsii field in package.json
+// We accept all value for these
+const configurable = new validator_1.RuleSet();
+configurable.shouldPass('outdir', validator_1.Match.ANY);
+configurable.shouldPass('rootDir', validator_1.Match.ANY);
+configurable.shouldPass('forceConsistentCasingInFileNames', validator_1.Match.ANY);
+configurable.shouldPass('declarationMap', validator_1.Match.ANY);
+configurable.shouldPass('inlineSourceMap', validator_1.Match.ANY);
+configurable.shouldPass('inlineSources', validator_1.Match.ANY);
+configurable.shouldPass('sourceMap', validator_1.Match.ANY);
+configurable.shouldPass('types', validator_1.Match.ANY);
+configurable.shouldPass('baseUrl', validator_1.Match.ANY);
+configurable.shouldPass('paths', validator_1.Match.ANY);
+configurable.shouldPass('composite', validator_1.Match.ANY); // configured via projectReferences
+configurable.shouldPass('tsBuildInfoFile', validator_1.Match.ANY);
+exports.default = configurable;
+//# sourceMappingURL=configurable.js.map

package/lib/tsconfig/rulesets/configurable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurable.js","sourceRoot":"","sources":["../../../src/tsconfig/rulesets/configurable.ts"],"names":[],"mappings":";;AAAA,4CAA8C;AAE9C,uGAAuG;AACvG,qEAAqE;AAErE,sEAAsE;AACtE,gCAAgC;AAChC,MAAM,YAAY,GAAG,IAAI,mBAAO,EAAE,CAAC;AACnC,YAAY,CAAC,UAAU,CAAC,QAAQ,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAC7C,YAAY,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAC9C,YAAY,CAAC,UAAU,CAAC,kCAAkC,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AACvE,YAAY,CAAC,UAAU,CAAC,gBAAgB,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AACrD,YAAY,CAAC,UAAU,CAAC,iBAAiB,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AACtD,YAAY,CAAC,UAAU,CAAC,eAAe,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AACpD,YAAY,CAAC,UAAU,CAAC,WAAW,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAChD,YAAY,CAAC,UAAU,CAAC,OAAO,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAC5C,YAAY,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAC9C,YAAY,CAAC,UAAU,CAAC,OAAO,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAC5C,YAAY,CAAC,UAAU,CAAC,WAAW,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC,CAAC,mCAAmC;AACpF,YAAY,CAAC,UAAU,CAAC,iBAAiB,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAEtD,kBAAe,YAAY,CAAC","sourcesContent":["import { Match, RuleSet } from '../validator';\n\n// A rule set defining all compilerOptions that can be configured by users with or without constraints.\n// This is an internal rule set, that may be used by other rule sets.\n\n// Settings previously configurable via the jsii field in package.json\n// We accept all value for these\nconst configurable = new RuleSet();\nconfigurable.shouldPass('outdir', Match.ANY);\nconfigurable.shouldPass('rootDir', Match.ANY);\nconfigurable.shouldPass('forceConsistentCasingInFileNames', Match.ANY);\nconfigurable.shouldPass('declarationMap', Match.ANY);\nconfigurable.shouldPass('inlineSourceMap', Match.ANY);\nconfigurable.shouldPass('inlineSources', Match.ANY);\nconfigurable.shouldPass('sourceMap', Match.ANY);\nconfigurable.shouldPass('types', Match.ANY);\nconfigurable.shouldPass('baseUrl', Match.ANY);\nconfigurable.shouldPass('paths', Match.ANY);\nconfigurable.shouldPass('composite', Match.ANY); // configured via projectReferences\nconfigurable.shouldPass('tsBuildInfoFile', Match.ANY);\n\nexport default configurable;\n"]}

package/lib/tsconfig/rulesets/generated.public.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from '../validator';
+declare const generated: RuleSet;
+export default generated;
+//# sourceMappingURL=generated.public.d.ts.map

package/lib/tsconfig/rulesets/generated.public.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configurable_1 = require("./configurable");
+const compiler_options_1 = require("../compiler-options");
+const validator_1 = require("../validator");
+// The public rule set used for the "generated" tsconfig validation setting.\
+// The goal of this rule set is to ensure a tsconfig is compatible to the one jsii would generate for the user.
+// It is explicitly enforcing option values that are used for the generated tsconfig,
+// as well as options that can be configured via jsii settings. All other options are disallowed.
+const generated = new validator_1.RuleSet({
+    unexpectedFields: validator_1.RuleType.FAIL,
+});
+// import all options that are configurable via jsii settings
+generated.import(configurable_1.default);
+// ... and all generated options
+for (const [field, value] of Object.entries((0, compiler_options_1.convertForJson)(compiler_options_1.BASE_COMPILER_OPTIONS))) {
+    if (typeof value === 'string') {
+        generated.shouldPass(field, validator_1.Match.strEq(value, true));
+        continue;
+    }
+    if (Array.isArray(value)) {
+        generated.shouldPass(field, validator_1.Match.arrEq(value));
+        continue;
+    }
+    generated.shouldPass(field, validator_1.Match.eq(value));
+}
+exports.default = generated;
+//# sourceMappingURL=generated.public.js.map

package/lib/tsconfig/rulesets/generated.public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated.public.js","sourceRoot":"","sources":["../../../src/tsconfig/rulesets/generated.public.ts"],"names":[],"mappings":";;AAAA,iDAA0C;AAC1C,0DAA4E;AAC5E,4CAAwD;AAExD,6EAA6E;AAC7E,+GAA+G;AAC/G,qFAAqF;AACrF,iGAAiG;AACjG,MAAM,SAAS,GAAG,IAAI,mBAAO,CAAC;IAC5B,gBAAgB,EAAE,oBAAQ,CAAC,IAAI;CAChC,CAAC,CAAC;AAEH,6DAA6D;AAC7D,SAAS,CAAC,MAAM,CAAC,sBAAY,CAAC,CAAC;AAE/B,gCAAgC;AAChC,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAA,iCAAc,EAAC,wCAAqB,CAAC,CAAC,EAAE,CAAC;IACnF,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,iBAAK,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QACtD,SAAS;IACX,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,iBAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAChD,SAAS;IACX,CAAC;IAED,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,iBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED,kBAAe,SAAS,CAAC","sourcesContent":["import configurable from './configurable';\nimport { BASE_COMPILER_OPTIONS, convertForJson } from '../compiler-options';\nimport { Match, RuleSet, RuleType } from '../validator';\n\n// The public rule set used for the \"generated\" tsconfig validation setting.\\\n// The goal of this rule set is to ensure a tsconfig is compatible to the one jsii would generate for the user.\n// It is explicitly enforcing option values that are used for the generated tsconfig,\n// as well as options that can be configured via jsii settings. All other options are disallowed.\nconst generated = new RuleSet({\n  unexpectedFields: RuleType.FAIL,\n});\n\n// import all options that are configurable via jsii settings\ngenerated.import(configurable);\n\n// ... and all generated options\nfor (const [field, value] of Object.entries(convertForJson(BASE_COMPILER_OPTIONS))) {\n  if (typeof value === 'string') {\n    generated.shouldPass(field, Match.strEq(value, true));\n    continue;\n  }\n\n  if (Array.isArray(value)) {\n    generated.shouldPass(field, Match.arrEq(value));\n    continue;\n  }\n\n  generated.shouldPass(field, Match.eq(value));\n}\n\nexport default generated;\n"]}

package/lib/tsconfig/rulesets/incompatible-options.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from '../validator';
+declare const incompatibleOptions: RuleSet;
+export default incompatibleOptions;
+//# sourceMappingURL=incompatible-options.d.ts.map

package/lib/tsconfig/rulesets/incompatible-options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+// A rule set defining all compilerOptions that are explicitly known to be incompatible with jsii
+// This is an internal rule set, that may be used by other rule sets.
+const incompatibleOptions = new validator_1.RuleSet();
+incompatibleOptions.shouldFail('noEmit', validator_1.Match.TRUE);
+incompatibleOptions.shouldFail('noLib', validator_1.Match.TRUE);
+incompatibleOptions.shouldFail('declaration', validator_1.Match.FALSE);
+exports.default = incompatibleOptions;
+//# sourceMappingURL=incompatible-options.js.map

package/lib/tsconfig/rulesets/incompatible-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incompatible-options.js","sourceRoot":"","sources":["../../../src/tsconfig/rulesets/incompatible-options.ts"],"names":[],"mappings":";;AAAA,4CAA8C;AAE9C,iGAAiG;AACjG,qEAAqE;AACrE,MAAM,mBAAmB,GAAG,IAAI,mBAAO,EAAE,CAAC;AAC1C,mBAAmB,CAAC,UAAU,CAAC,QAAQ,EAAE,iBAAK,CAAC,IAAI,CAAC,CAAC;AACrD,mBAAmB,CAAC,UAAU,CAAC,OAAO,EAAE,iBAAK,CAAC,IAAI,CAAC,CAAC;AACpD,mBAAmB,CAAC,UAAU,CAAC,aAAa,EAAE,iBAAK,CAAC,KAAK,CAAC,CAAC;AAE3D,kBAAe,mBAAmB,CAAC","sourcesContent":["import { Match, RuleSet } from '../validator';\n\n// A rule set defining all compilerOptions that are explicitly known to be incompatible with jsii\n// This is an internal rule set, that may be used by other rule sets.\nconst incompatibleOptions = new RuleSet();\nincompatibleOptions.shouldFail('noEmit', Match.TRUE);\nincompatibleOptions.shouldFail('noLib', Match.TRUE);\nincompatibleOptions.shouldFail('declaration', Match.FALSE);\n\nexport default incompatibleOptions;\n"]}

package/lib/tsconfig/rulesets/minimal.public.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from '../validator';
+declare const minimal: RuleSet;
+export default minimal;
+//# sourceMappingURL=minimal.public.d.ts.map

package/lib/tsconfig/rulesets/minimal.public.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const incompatible_options_1 = require("./incompatible-options");
+const validator_1 = require("../validator");
+// The public rule set used for the "minimal" tsconfig validation setting
+// To goal of this rule set is to only prevent obvious misconfigurations,
+// while leaving everything else up to the user.
+const minimal = new validator_1.RuleSet();
+minimal.import(incompatible_options_1.default);
+exports.default = minimal;
+//# sourceMappingURL=minimal.public.js.map

package/lib/tsconfig/rulesets/minimal.public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal.public.js","sourceRoot":"","sources":["../../../src/tsconfig/rulesets/minimal.public.ts"],"names":[],"mappings":";;AAAA,iEAAkD;AAClD,4CAAuC;AAEvC,yEAAyE;AACzE,yEAAyE;AACzE,gDAAgD;AAChD,MAAM,OAAO,GAAG,IAAI,mBAAO,EAAE,CAAC;AAC9B,OAAO,CAAC,MAAM,CAAC,8BAAY,CAAC,CAAC;AAE7B,kBAAe,OAAO,CAAC","sourcesContent":["import incompatible from './incompatible-options';\nimport { RuleSet } from '../validator';\n\n// The public rule set used for the \"minimal\" tsconfig validation setting\n// To goal of this rule set is to only prevent obvious misconfigurations,\n// while leaving everything else up to the user.\nconst minimal = new RuleSet();\nminimal.import(incompatible);\n\nexport default minimal;\n"]}

package/lib/tsconfig/rulesets/strict.public.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from '../validator';
+declare const strict: RuleSet;
+export default strict;
+//# sourceMappingURL=strict.public.d.ts.map

package/lib/tsconfig/rulesets/strict.public.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configurable_1 = require("./configurable");
+const incompatible_options_1 = require("./incompatible-options");
+const validator_1 = require("../validator");
+// The public rule set used for the "strict" tsconfig validation setting.
+// The goal of this rule set is to ensure a tsconfig that is following best practices for jsii.
+// In practice, this is a combination of known incompatible options, known configurable options and additional best practices.
+// The rule set also explicitly disallows unknown options.
+const strict = new validator_1.RuleSet({
+    unexpectedFields: validator_1.RuleType.FAIL,
+});
+// import all options that are configurable
+strict.import(configurable_1.default);
+// import all options that are definitely incompatible
+strict.import(incompatible_options_1.default);
+// Best practice rules
+strict.shouldPass('target', validator_1.Match.eq('es2022')); // node18
+strict.shouldPass('lib', validator_1.Match.arrEq(['es2022'])); // node18
+strict.shouldPass('module', validator_1.Match.oneOf('node16', 'commonjs'));
+strict.shouldPass('moduleResolution', validator_1.Match.optional(validator_1.Match.oneOf('node', 'node16')));
+strict.shouldPass('esModuleInterop', validator_1.Match.TRUE);
+strict.shouldPass('skipLibCheck', validator_1.Match.TRUE);
+strict.shouldPass('strict', validator_1.Match.eq(true));
+strict.shouldPass('incremental', validator_1.Match.ANY);
+// Deprecated ts options that should not be used with jsii
+strict.shouldPass('prepend', validator_1.Match.MISSING);
+exports.default = strict;
+//# sourceMappingURL=strict.public.js.map

package/lib/tsconfig/rulesets/strict.public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict.public.js","sourceRoot":"","sources":["../../../src/tsconfig/rulesets/strict.public.ts"],"names":[],"mappings":";;AAAA,iDAA0C;AAC1C,iEAAkD;AAClD,4CAAwD;AAExD,yEAAyE;AACzE,+FAA+F;AAC/F,8HAA8H;AAC9H,0DAA0D;AAC1D,MAAM,MAAM,GAAG,IAAI,mBAAO,CAAC;IACzB,gBAAgB,EAAE,oBAAQ,CAAC,IAAI;CAChC,CAAC,CAAC;AAEH,2CAA2C;AAC3C,MAAM,CAAC,MAAM,CAAC,sBAAY,CAAC,CAAC;AAE5B,sDAAsD;AACtD,MAAM,CAAC,MAAM,CAAC,8BAAY,CAAC,CAAC;AAE5B,sBAAsB;AACtB,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,iBAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;AAC1D,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,iBAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;AAC5D,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,iBAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;AAC/D,MAAM,CAAC,UAAU,CAAC,kBAAkB,EAAE,iBAAK,CAAC,QAAQ,CAAC,iBAAK,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;AACrF,MAAM,CAAC,UAAU,CAAC,iBAAiB,EAAE,iBAAK,CAAC,IAAI,CAAC,CAAC;AACjD,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,iBAAK,CAAC,IAAI,CAAC,CAAC;AAC9C,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,iBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5C,MAAM,CAAC,UAAU,CAAC,aAAa,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;AAE5C,0DAA0D;AAC1D,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,OAAO,CAAC,CAAC;AAE5C,kBAAe,MAAM,CAAC","sourcesContent":["import configurable from './configurable';\nimport incompatible from './incompatible-options';\nimport { Match, RuleSet, RuleType } from '../validator';\n\n// The public rule set used for the \"strict\" tsconfig validation setting.\n// The goal of this rule set is to ensure a tsconfig that is following best practices for jsii.\n// In practice, this is a combination of known incompatible options, known configurable options and additional best practices.\n// The rule set also explicitly disallows unknown options.\nconst strict = new RuleSet({\n  unexpectedFields: RuleType.FAIL,\n});\n\n// import all options that are configurable\nstrict.import(configurable);\n\n// import all options that are definitely incompatible\nstrict.import(incompatible);\n\n// Best practice rules\nstrict.shouldPass('target', Match.eq('es2022')); // node18\nstrict.shouldPass('lib', Match.arrEq(['es2022'])); // node18\nstrict.shouldPass('module', Match.oneOf('node16', 'commonjs'));\nstrict.shouldPass('moduleResolution', Match.optional(Match.oneOf('node', 'node16')));\nstrict.shouldPass('esModuleInterop', Match.TRUE);\nstrict.shouldPass('skipLibCheck', Match.TRUE);\nstrict.shouldPass('strict', Match.eq(true));\nstrict.shouldPass('incremental', Match.ANY);\n\n// Deprecated ts options that should not be used with jsii\nstrict.shouldPass('prepend', Match.MISSING);\n\nexport default strict;\n"]}

package/lib/tsconfig/tsconfig-validator.d.ts

@@ -0,0 +1,16 @@
+import { TypeScriptConfig, TypeScriptConfigValidationRuleSet } from '.';
+export declare class TypeScriptConfigValidator {
+    ruleSet: TypeScriptConfigValidationRuleSet;
+    private readonly validator;
+    private readonly compilerOptions;
+    constructor(ruleSet: TypeScriptConfigValidationRuleSet);
+    /**
+     * Validated the provided config against the set of rules.
+     *
+     * @throws when the config is invalid
+     *
+     * @param tsconfig the tsconfig to be validated, this MUST be a tsconfig as a user would have written it in tsconfig.
+     */
+    validate(tsconfig: TypeScriptConfig): void;
+}
+//# sourceMappingURL=tsconfig-validator.d.ts.map

package/lib/tsconfig/tsconfig-validator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptConfigValidator = void 0;
+const generated_public_1 = require("./rulesets/generated.public");
+const minimal_public_1 = require("./rulesets/minimal.public");
+const strict_public_1 = require("./rulesets/strict.public");
+const validator_1 = require("./validator");
+const RuleSets = {
+    generated: generated_public_1.default,
+    strict: strict_public_1.default,
+    minimal: minimal_public_1.default,
+    off: new validator_1.RuleSet(),
+};
+class TypeScriptConfigValidator {
+    constructor(ruleSet) {
+        this.ruleSet = ruleSet;
+        const topLevelRules = new validator_1.RuleSet({
+            unexpectedFields: validator_1.RuleType.PASS,
+        });
+        topLevelRules.shouldPass('files', validator_1.Match.ANY);
+        topLevelRules.shouldPass('extends', validator_1.Match.ANY);
+        topLevelRules.shouldPass('include', validator_1.Match.ANY);
+        topLevelRules.shouldPass('exclude', validator_1.Match.ANY);
+        topLevelRules.shouldPass('references', validator_1.Match.ANY);
+        topLevelRules.shouldPass('watchOptions', validator_1.Match.ANY);
+        topLevelRules.shouldPass('typeAcquisition', validator_1.Match.MISSING);
+        this.compilerOptions = new validator_1.ObjectValidator(RuleSets[ruleSet], 'compilerOptions');
+        topLevelRules.shouldPass('compilerOptions', (compilerOptions) => {
+            this.compilerOptions.validate(compilerOptions);
+            return true;
+        });
+        this.validator = new validator_1.ObjectValidator(topLevelRules, 'tsconfig');
+    }
+    /**
+     * Validated the provided config against the set of rules.
+     *
+     * @throws when the config is invalid
+     *
+     * @param tsconfig the tsconfig to be validated, this MUST be a tsconfig as a user would have written it in tsconfig.
+     */
+    validate(tsconfig) {
+        this.validator.validate(tsconfig);
+    }
+}
+exports.TypeScriptConfigValidator = TypeScriptConfigValidator;
+//# sourceMappingURL=tsconfig-validator.js.map

package/lib/tsconfig/tsconfig-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-validator.js","sourceRoot":"","sources":["../../src/tsconfig/tsconfig-validator.ts"],"names":[],"mappings":";;;AACA,kEAAoD;AACpD,8DAAgD;AAChD,4DAA8C;AAC9C,2CAAwE;AAExE,MAAM,QAAQ,GAEV;IACF,SAAS,EAAT,0BAAS;IACT,MAAM,EAAN,uBAAM;IACN,OAAO,EAAP,wBAAO;IACP,GAAG,EAAE,IAAI,mBAAO,EAAE;CACnB,CAAC;AAEF,MAAa,yBAAyB;IAIpC,YAA0B,OAA0C;QAA1C,YAAO,GAAP,OAAO,CAAmC;QAClE,MAAM,aAAa,GAAG,IAAI,mBAAO,CAAC;YAChC,gBAAgB,EAAE,oBAAQ,CAAC,IAAI;SAChC,CAAC,CAAC;QACH,aAAa,CAAC,UAAU,CAAC,OAAO,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QAC7C,aAAa,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QAC/C,aAAa,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QAC/C,aAAa,CAAC,UAAU,CAAC,SAAS,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QAC/C,aAAa,CAAC,UAAU,CAAC,YAAY,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QAClD,aAAa,CAAC,UAAU,CAAC,cAAc,EAAE,iBAAK,CAAC,GAAG,CAAC,CAAC;QACpD,aAAa,CAAC,UAAU,CAAC,iBAAiB,EAAE,iBAAK,CAAC,OAAO,CAAC,CAAC;QAE3D,IAAI,CAAC,eAAe,GAAG,IAAI,2BAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,CAAC;QACjF,aAAa,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC,eAAe,EAAE,EAAE;YAC9D,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAC/C,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,IAAI,2BAAe,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,QAA0B;QACxC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;CACF;AAnCD,8DAmCC","sourcesContent":["import { TypeScriptConfig, TypeScriptConfigValidationRuleSet } from '.';\nimport generated from './rulesets/generated.public';\nimport minimal from './rulesets/minimal.public';\nimport strict from './rulesets/strict.public';\nimport { Match, ObjectValidator, RuleSet, RuleType } from './validator';\n\nconst RuleSets: {\n  [name in TypeScriptConfigValidationRuleSet]: RuleSet;\n} = {\n  generated,\n  strict,\n  minimal,\n  off: new RuleSet(),\n};\n\nexport class TypeScriptConfigValidator {\n  private readonly validator: ObjectValidator;\n  private readonly compilerOptions: ObjectValidator;\n\n  public constructor(public ruleSet: TypeScriptConfigValidationRuleSet) {\n    const topLevelRules = new RuleSet({\n      unexpectedFields: RuleType.PASS,\n    });\n    topLevelRules.shouldPass('files', Match.ANY);\n    topLevelRules.shouldPass('extends', Match.ANY);\n    topLevelRules.shouldPass('include', Match.ANY);\n    topLevelRules.shouldPass('exclude', Match.ANY);\n    topLevelRules.shouldPass('references', Match.ANY);\n    topLevelRules.shouldPass('watchOptions', Match.ANY);\n    topLevelRules.shouldPass('typeAcquisition', Match.MISSING);\n\n    this.compilerOptions = new ObjectValidator(RuleSets[ruleSet], 'compilerOptions');\n    topLevelRules.shouldPass('compilerOptions', (compilerOptions) => {\n      this.compilerOptions.validate(compilerOptions);\n      return true;\n    });\n\n    this.validator = new ObjectValidator(topLevelRules, 'tsconfig');\n  }\n\n  /**\n   * Validated the provided config against the set of rules.\n   *\n   * @throws when the config is invalid\n   *\n   * @param tsconfig the tsconfig to be validated, this MUST be a tsconfig as a user would have written it in tsconfig.\n   */\n  public validate(tsconfig: TypeScriptConfig) {\n    this.validator.validate(tsconfig);\n  }\n}\n"]}

package/lib/tsconfig/validator.d.ts

@@ -0,0 +1,155 @@
+/**
+ * A function that receives 3 arguments and validates if the provided value matches.
+ * @param value The value to validate
+ * @params options Additional options to influence the matcher behavior.
+ * @returns true if the value matches
+ */
+type Matcher = (value: any, options?: MatcherOptions) => boolean;
+interface MatcherOptions {
+    /**
+     * A function that will be called by the matcher with a a violation message.
+     * This function is always called, regardless of the outcome of the matcher.
+     * It is up to the caller of the matcher to decide if the message should be used or not.
+     *
+     * @param message The message describing the possible failure.
+     */
+    reporter?: (message: string) => void;
+    /**
+     * A function that might receive explicitly allowed values.
+     * This can be used to generate synthetics values that would match the matcher.
+     * It is not guaranteed that hints are received or that hints are complete.
+     *
+     * @param allowed The list values that a matcher offers as definitely allowed.
+     */
+    hints?: (allowed: any[]) => void;
+}
+export declare enum RuleType {
+    PASS = 0,
+    FAIL = 1
+}
+export interface RuleSetOptions {
+    /**
+     * Defines the behavior for any encountered fields for which no rules are defined.
+     * The default is to pass these fields without validation,
+     * but this can also be set to fail any unexpected fields.
+     *
+     * @default RuleType.PASS
+     */
+    readonly unexpectedFields: RuleType;
+}
+interface Rule {
+    field: string;
+    type: RuleType;
+    matcher: Matcher;
+}
+export declare class RuleSet {
+    readonly options: RuleSetOptions;
+    private _rules;
+    get rules(): Array<Rule>;
+    /**
+     * Return all fields for which a rule exists
+     */
+    get fields(): Array<string>;
+    /**
+     * Return a list of fields that are allowed, or undefined if all are allowed.
+     */
+    get allowedFields(): Array<string> | undefined;
+    /**
+     * Find all required fields by evaluating every rule in th set against undefined.
+     * If the rule fails, the key must be required.
+     *
+     * @returns A list of keys that must be included or undefined
+     */
+    get requiredFields(): Array<string>;
+    constructor(options?: RuleSetOptions);
+    /**
+     * Requires the matcher to pass for the given field.
+     * Otherwise a violation is detected.
+     *
+     * @param field The field the rule applies to
+     * @param matcher The matcher function
+     */
+    shouldPass(field: string, matcher: Matcher): void;
+    /**
+     * Detects a violation if the matcher is matching for a certain field.
+     *
+     * @param field The field the rule applies to
+     * @param matcher The matcher function
+     */
+    shouldFail(field: string, matcher: Matcher): void;
+    /**
+     * Imports all rules from an other rule set.
+     * Note that any options from the other rule set will be ignored.
+     *
+     * @param other The other rule set to import rules from.
+     */
+    import(other: RuleSet): void;
+    /**
+     * Records the field hints for the given rule set.
+     * Hints are values that are guaranteed to pass the rule.
+     * The list of hints is not guaranteed to be complete nor does it guarantee to return any values.
+     * This can be used to create synthetic values for testing for error messages.
+     *
+     * @returns A record of fields and allowed values
+     */
+    getFieldHints(): Record<string, any[]>;
+}
+export declare class Match {
+    /**
+     * Value is optional, but if present should match
+     */
+    static optional(matcher: Matcher): Matcher;
+    /**
+     * Value must be one of the allowed options
+     */
+    static oneOf(...allowed: Array<string | number>): Matcher;
+    /**
+     * Value must be loosely equal to the expected value
+     * Arrays are compared by elements
+     */
+    static eq(expected: any): Matcher;
+    /**
+     * Value must be loosely equal to the expected value
+     * Arrays are compared by elements
+     */
+    static arrEq(expected: any[]): Matcher;
+    /**
+     * Compare strings, allows setting cases sensitivity
+     */
+    static strEq(expected: string, caseSensitive?: boolean): Matcher;
+    /**
+     * Allows any value
+     */
+    static ANY: Matcher;
+    static TRUE: Matcher;
+    static FALSE: Matcher;
+    /**
+     * Missing (undefined) value
+     */
+    static MISSING: Matcher;
+}
+export interface Violation {
+    field: string;
+    message: string;
+}
+export declare class ValidationError extends Error {
+    readonly violations: Violation[];
+    constructor(violations: Violation[]);
+}
+export declare class ObjectValidator {
+    ruleSet: RuleSet;
+    private readonly dataName;
+    constructor(ruleSet: RuleSet, dataName?: string);
+    /**
+     * Validated the provided data against the set of rules.
+     *
+     * @throws when the data is invalid
+     *
+     * @param data the data to be validated
+     */
+    validate(data: {
+        [field: string]: any;
+    }): void;
+}
+export {};
+//# sourceMappingURL=validator.d.ts.map