@formspec/eslint-plugin 0.1.0-alpha.10

package/README.md

@@ -0,0 +1,237 @@
+# @your-org/eslint-plugin
+
+ESLint rules for working with your schema/constraints.
+
+## Rules
+
+| Rule name               | Description                                                     |
+| ----------------------- | --------------------------------------------------------------- |
+| `consistent-constraints` | Enforces consistent min/max and related constraints in schemas. |
+
+## Rule details
+
+### `consistent-constraints`
+
+This rule validates that constraint-related properties (such as minimum and maximum
+values, lengths, or ranges) are used consistently and do not contradict each other.
+
+It is intended as a replacement for the now-removed `min-max-valid-range` rule and
+should be enabled wherever constraint consistency needs to be enforced.
+
+<!-- Add additional rules and documentation here as needed. -->
+# @formspec/eslint-plugin
+
+ESLint plugin for validating FormSpec decorator DSL usage in TypeScript projects. This plugin catches common mistakes by ensuring decorators match their field types and enforcing consistency rules.
+
+## Installation
+
+```bash
+npm install --save-dev @formspec/eslint-plugin
+# or
+pnpm add -D @formspec/eslint-plugin
+```
+
+## Requirements
+
+- ESLint v9+ (flat config)
+- TypeScript v5+
+
+## Usage
+
+### Recommended Configuration
+
+Add the plugin to your `eslint.config.js`:
+
+```javascript
+import formspec from "@formspec/eslint-plugin";
+
+export default [
+  // ... other configs
+  ...formspec.configs.recommended,
+];
+```
+
+### Manual Configuration
+
+```javascript
+import formspec from "@formspec/eslint-plugin";
+
+export default [
+  {
+    plugins: {
+      "@formspec": formspec,
+    },
+    rules: {
+      "@formspec/decorator-field-type-mismatch": "error",
+      "@formspec/enum-options-match-type": "error",
+      "@formspec/showwhen-field-exists": "error",
+      "@formspec/showwhen-suggests-optional": "warn",
+      "@formspec/min-max-valid-range": "error",
+      "@formspec/no-conflicting-decorators": "error",
+      "@formspec/no-duplicate-decorators": "error",
+    },
+  },
+];
+```
+
+## Rules
+
+| Rule                                                              | Description                                                    | Recommended | Strict |
+| ----------------------------------------------------------------- | -------------------------------------------------------------- | ----------- | ------ |
+| [`decorator-field-type-mismatch`](#decorator-field-type-mismatch) | Ensures decorators are applied to fields with compatible types | error       | error  |
+| [`enum-options-match-type`](#enum-options-match-type)             | Ensures @EnumOptions values match the field's union type       | error       | error  |
+| [`showwhen-field-exists`](#showwhen-field-exists)                 | Ensures @ShowWhen references a field that exists               | error       | error  |
+| [`showwhen-suggests-optional`](#showwhen-suggests-optional)       | Suggests @ShowWhen fields should be optional                   | warn        | error  |
+| [`min-max-valid-range`](#min-max-valid-range)                     | Ensures @Min/@Max have valid ranges                            | error       | error  |
+| [`no-conflicting-decorators`](#no-conflicting-decorators)         | Prevents decorators that imply conflicting types               | error       | error  |
+| [`no-duplicate-decorators`](#no-duplicate-decorators)             | Prevents duplicate decorators on the same field                | error       | error  |
+
+### decorator-field-type-mismatch
+
+Ensures FormSpec decorators are applied to fields with compatible types.
+
+```typescript
+// Valid
+@Min(0)
+@Max(100)
+age!: number;
+
+@Placeholder("Enter name")
+name!: string;
+
+@MinItems(1)
+@MaxItems(10)
+items!: string[];
+
+// Invalid - @Min requires number field
+@Min(0)
+name!: string; // Error: @Min can only be used on number fields
+```
+
+### enum-options-match-type
+
+Ensures @EnumOptions values match the field's TypeScript union type.
+
+```typescript
+// Valid - options match type
+@EnumOptions(["draft", "published", "archived"])
+status!: "draft" | "published" | "archived";
+
+// Valid - object options with id property
+@EnumOptions([{ id: "a", label: "Option A" }, { id: "b", label: "Option B" }])
+type!: "a" | "b";
+
+// Valid - string type accepts any options
+@EnumOptions(["any", "options"])
+value!: string;
+
+// Invalid - missing option "archived"
+@EnumOptions(["draft", "published"])
+status!: "draft" | "published" | "archived"; // Error: missing "archived"
+```
+
+### showwhen-field-exists
+
+Ensures @ShowWhen references a field that exists in the same class.
+
+```typescript
+// Valid
+@EnumOptions(["a", "b"])
+type!: "a" | "b";
+
+@ShowWhen({ _predicate: "equals", field: "type", value: "a" })
+conditionalField?: string;
+
+// Invalid - "nonexistent" field doesn't exist
+@ShowWhen({ _predicate: "equals", field: "nonexistent", value: "x" })
+conditionalField?: string; // Error: field "nonexistent" does not exist
+```
+
+### showwhen-suggests-optional
+
+Suggests that fields with @ShowWhen should be marked as optional since they may not be present in the output.
+
+```typescript
+// Valid
+@ShowWhen({ _predicate: "equals", field: "type", value: "a" })
+conditionalField?: string; // Good - optional
+
+// Warning
+@ShowWhen({ _predicate: "equals", field: "type", value: "a" })
+conditionalField!: string; // Warning: should be optional
+```
+
+### min-max-valid-range
+
+Ensures @Min value is less than or equal to @Max value.
+
+```typescript
+// Valid
+@Min(0)
+@Max(100)
+value!: number;
+
+@Min(5)
+@Max(5) // Equal is valid
+exact!: number;
+
+// Invalid
+@Min(100)
+@Max(50) // Error: @Min(100) > @Max(50)
+invalid!: number;
+```
+
+### no-conflicting-decorators
+
+Prevents using decorators that imply conflicting field types.
+
+```typescript
+// Valid - both imply number
+@Min(0)
+@Max(100)
+value!: number;
+
+// Invalid - @Min implies number, @Placeholder implies string
+@Min(0)
+@Placeholder("Enter value") // Error: conflicting decorators
+field!: string;
+```
+
+### no-duplicate-decorators
+
+Prevents applying the same decorator multiple times to a field.
+
+```typescript
+// Valid
+@Label("Name")
+@Placeholder("Enter name")
+name!: string;
+
+// Invalid
+@Label("First")
+@Label("Second") // Error: duplicate @Label
+name!: string;
+```
+
+## Configurations
+
+### Recommended
+
+Sensible defaults for most projects:
+
+- All type safety rules enabled as errors
+- `showwhen-suggests-optional` as warning (not blocking)
+
+### Strict
+
+All rules enabled as errors for maximum type safety enforcement.
+
+```javascript
+import formspec from "@formspec/eslint-plugin";
+
+export default [...formspec.configs.strict];
+```
+
+## License
+
+UNLICENSED

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @formspec/eslint-plugin
+ *
+ * ESLint plugin for FormSpec type safety and constraint validation.
+ *
+ * Provides rules to:
+ * - Catch common mistakes when using FormSpec decorators
+ * - Validate Chain DSL usage against project constraints
+ * - Ensure forms comply with target environment capabilities
+ */
+import type { TSESLint } from "@typescript-eslint/utils";
+import { decoratorFieldTypeMismatch } from "./rules/decorator-field-type-mismatch.js";
+import { enumOptionsMatchType } from "./rules/enum-options-match-type.js";
+import { showwhenFieldExists } from "./rules/showwhen-field-exists.js";
+import { showwhenSuggestsOptional } from "./rules/showwhen-suggests-optional.js";
+import { consistentConstraints } from "./rules/consistent-constraints.js";
+import { noConflictingDecorators } from "./rules/no-conflicting-decorators.js";
+import { noDuplicateDecorators } from "./rules/no-duplicate-decorators.js";
+import { decoratorAllowedFieldTypes } from "./rules/decorator-allowed-field-types.js";
+import { preferCustomDecorator } from "./rules/prefer-custom-decorator.js";
+import { allowedFieldTypes, allowedLayouts } from "./rules/constraints/index.js";
+/**
+ * The FormSpec ESLint plugin.
+ */
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        readonly "decorator-field-type-mismatch": TSESLint.RuleModule<"numericOnNonNumber" | "stringOnNonString", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "enum-options-match-type": TSESLint.RuleModule<"enumOptionsMismatch" | "enumOptionsMissing" | "enumOptionsExtra", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "showwhen-field-exists": TSESLint.RuleModule<"fieldDoesNotExist", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "showwhen-suggests-optional": TSESLint.RuleModule<"shouldBeOptional", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "consistent-constraints": TSESLint.RuleModule<"minimumGreaterThanMaximum" | "exclusiveMinGreaterOrEqualMax" | "minLengthGreaterThanMaxLength" | "conflictingMinimumBounds" | "conflictingMaximumBounds" | "exclusiveMaxLessOrEqualMin" | "maximumLessOrEqualExclusiveMin" | "duplicateConstraintSource", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "no-conflicting-decorators": TSESLint.RuleModule<"conflictingDecorators", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "no-duplicate-decorators": TSESLint.RuleModule<"duplicateDecorator", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "decorator-allowed-field-types": TSESLint.RuleModule<"disallowedFieldType", [import("./rules/decorator-allowed-field-types.js").DecoratorAllowedFieldTypesOptions], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "prefer-custom-decorator": TSESLint.RuleModule<"preferCustomDecorator", [import("./rules/prefer-custom-decorator.js").PreferCustomDecoratorOptions], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "constraints-allowed-field-types": TSESLint.RuleModule<"disallowedFieldType", import("./rules/constraints/allowed-field-types.js").Options, unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        readonly "constraints-allowed-layouts": TSESLint.RuleModule<"disallowedGroup" | "disallowedConditional", import("./rules/constraints/allowed-layouts.js").Options, unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+    };
+    configs: {
+        recommended: TSESLint.FlatConfig.ConfigArray;
+        strict: TSESLint.FlatConfig.ConfigArray;
+    };
+};
+export default plugin;
+export { decoratorFieldTypeMismatch, enumOptionsMatchType, showwhenFieldExists, showwhenSuggestsOptional, consistentConstraints, noConflictingDecorators, noDuplicateDecorators, decoratorAllowedFieldTypes, preferCustomDecorator, allowedFieldTypes, allowedLayouts, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAG3E,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAoFjF;;GAEG;AACH,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOX,CAAC;AAEF,eAAe,MAAM,CAAC;AAGtB,OAAO,EAEL,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EAErB,iBAAiB,EACjB,cAAc,GACf,CAAC"}

package/dist/index.js

@@ -0,0 +1,117 @@
+/**
+ * @formspec/eslint-plugin
+ *
+ * ESLint plugin for FormSpec type safety and constraint validation.
+ *
+ * Provides rules to:
+ * - Catch common mistakes when using FormSpec decorators
+ * - Validate Chain DSL usage against project constraints
+ * - Ensure forms comply with target environment capabilities
+ */
+import { decoratorFieldTypeMismatch } from "./rules/decorator-field-type-mismatch.js";
+import { enumOptionsMatchType } from "./rules/enum-options-match-type.js";
+import { showwhenFieldExists } from "./rules/showwhen-field-exists.js";
+import { showwhenSuggestsOptional } from "./rules/showwhen-suggests-optional.js";
+import { consistentConstraints } from "./rules/consistent-constraints.js";
+import { noConflictingDecorators } from "./rules/no-conflicting-decorators.js";
+import { noDuplicateDecorators } from "./rules/no-duplicate-decorators.js";
+import { decoratorAllowedFieldTypes } from "./rules/decorator-allowed-field-types.js";
+import { preferCustomDecorator } from "./rules/prefer-custom-decorator.js";
+// Constraint rules for Chain DSL
+import { allowedFieldTypes, allowedLayouts } from "./rules/constraints/index.js";
+/**
+ * All rules provided by this plugin.
+ */
+const rules = {
+    // Decorator DSL rules
+    "decorator-field-type-mismatch": decoratorFieldTypeMismatch,
+    "enum-options-match-type": enumOptionsMatchType,
+    "showwhen-field-exists": showwhenFieldExists,
+    "showwhen-suggests-optional": showwhenSuggestsOptional,
+    "consistent-constraints": consistentConstraints,
+    "no-conflicting-decorators": noConflictingDecorators,
+    "no-duplicate-decorators": noDuplicateDecorators,
+    "decorator-allowed-field-types": decoratorAllowedFieldTypes,
+    "prefer-custom-decorator": preferCustomDecorator,
+    // Constraint rules for Chain DSL
+    "constraints-allowed-field-types": allowedFieldTypes,
+    "constraints-allowed-layouts": allowedLayouts,
+};
+/**
+ * Plugin metadata.
+ */
+const meta = {
+    name: "@formspec/eslint-plugin",
+};
+/**
+ * Recommended configuration for FormSpec projects.
+ *
+ * Usage:
+ * ```javascript
+ * import formspec from "@formspec/eslint-plugin";
+ *
+ * export default [
+ *   ...formspec.configs.recommended,
+ * ];
+ * ```
+ */
+const recommendedConfig = [
+    {
+        plugins: {
+            "@formspec": {
+                meta,
+                rules,
+            },
+        },
+        rules: {
+            "@formspec/decorator-field-type-mismatch": "error",
+            "@formspec/enum-options-match-type": "error",
+            "@formspec/showwhen-field-exists": "error",
+            "@formspec/showwhen-suggests-optional": "warn",
+            "@formspec/consistent-constraints": "error",
+            "@formspec/no-conflicting-decorators": "error",
+            "@formspec/no-duplicate-decorators": "error",
+        },
+    },
+];
+/**
+ * Strict configuration - all rules as errors.
+ */
+const strictConfig = [
+    {
+        plugins: {
+            "@formspec": {
+                meta,
+                rules,
+            },
+        },
+        rules: {
+            "@formspec/decorator-field-type-mismatch": "error",
+            "@formspec/enum-options-match-type": "error",
+            "@formspec/showwhen-field-exists": "error",
+            "@formspec/showwhen-suggests-optional": "error",
+            "@formspec/consistent-constraints": "error",
+            "@formspec/no-conflicting-decorators": "error",
+            "@formspec/no-duplicate-decorators": "error",
+        },
+    },
+];
+/**
+ * The FormSpec ESLint plugin.
+ */
+const plugin = {
+    meta,
+    rules,
+    configs: {
+        recommended: recommendedConfig,
+        strict: strictConfig,
+    },
+};
+export default plugin;
+// Named exports for individual rules
+export { 
+// Decorator DSL rules
+decoratorFieldTypeMismatch, enumOptionsMatchType, showwhenFieldExists, showwhenSuggestsOptional, consistentConstraints, noConflictingDecorators, noDuplicateDecorators, decoratorAllowedFieldTypes, preferCustomDecorator, 
+// Constraint rules for Chain DSL
+allowedFieldTypes, allowedLayouts, };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAE3E,iCAAiC;AACjC,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEjF;;GAEG;AACH,MAAM,KAAK,GAAG;IACZ,sBAAsB;IACtB,+BAA+B,EAAE,0BAA0B;IAC3D,yBAAyB,EAAE,oBAAoB;IAC/C,uBAAuB,EAAE,mBAAmB;IAC5C,4BAA4B,EAAE,wBAAwB;IACtD,wBAAwB,EAAE,qBAAqB;IAC/C,2BAA2B,EAAE,uBAAuB;IACpD,yBAAyB,EAAE,qBAAqB;IAChD,+BAA+B,EAAE,0BAA0B;IAC3D,yBAAyB,EAAE,qBAAqB;IAEhD,iCAAiC;IACjC,iCAAiC,EAAE,iBAAiB;IACpD,6BAA6B,EAAE,cAAc;CACrC,CAAC;AAEX;;GAEG;AACH,MAAM,IAAI,GAAG;IACX,IAAI,EAAE,yBAAyB;CAChC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,iBAAiB,GAAoC;IACzD;QACE,OAAO,EAAE;YACP,WAAW,EAAE;gBACX,IAAI;gBACJ,KAAK;aACN;SACF;QACD,KAAK,EAAE;YACL,yCAAyC,EAAE,OAAO;YAClD,mCAAmC,EAAE,OAAO;YAC5C,iCAAiC,EAAE,OAAO;YAC1C,sCAAsC,EAAE,MAAM;YAC9C,kCAAkC,EAAE,OAAO;YAC3C,qCAAqC,EAAE,OAAO;YAC9C,mCAAmC,EAAE,OAAO;SAC7C;KACF;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,YAAY,GAAoC;IACpD;QACE,OAAO,EAAE;YACP,WAAW,EAAE;gBACX,IAAI;gBACJ,KAAK;aACN;SACF;QACD,KAAK,EAAE;YACL,yCAAyC,EAAE,OAAO;YAClD,mCAAmC,EAAE,OAAO;YAC5C,iCAAiC,EAAE,OAAO;YAC1C,sCAAsC,EAAE,OAAO;YAC/C,kCAAkC,EAAE,OAAO;YAC3C,qCAAqC,EAAE,OAAO;YAC9C,mCAAmC,EAAE,OAAO;SAC7C;KACF;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,GAAG;IACb,IAAI;IACJ,KAAK;IACL,OAAO,EAAE;QACP,WAAW,EAAE,iBAAiB;QAC9B,MAAM,EAAE,YAAY;KACrB;CACF,CAAC;AAEF,eAAe,MAAM,CAAC;AAEtB,qCAAqC;AACrC,OAAO;AACL,sBAAsB;AACtB,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB;AACrB,iCAAiC;AACjC,iBAAiB,EACjB,cAAc,GACf,CAAC"}

package/dist/rules/consistent-constraints.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rule: consistent-constraints
+ *
+ * Ensures constraint decorator pairs have valid ranges and don't conflict:
+ * - @Minimum must be <= @Maximum
+ * - @ExclusiveMinimum must be < @ExclusiveMaximum
+ * - @MinLength must be <= @MaxLength
+ * - @Minimum and @ExclusiveMinimum must not both be present
+ * - @Maximum and @ExclusiveMaximum must not both be present
+ * - @Maximum(n) where n < @Minimum(m) is invalid
+ * - @ExclusiveMaximum(n) where n <= @Minimum(m) is invalid
+ *
+ * Constraints may come from decorators or JSDoc tags. If both a decorator
+ * and a JSDoc tag specify the same constraint, that is a lint error.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+type MessageIds = "minimumGreaterThanMaximum" | "exclusiveMinGreaterOrEqualMax" | "minLengthGreaterThanMaxLength" | "conflictingMinimumBounds" | "conflictingMaximumBounds" | "exclusiveMaxLessOrEqualMin" | "maximumLessOrEqualExclusiveMin" | "duplicateConstraintSource";
+export declare const consistentConstraints: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};
+//# sourceMappingURL=consistent-constraints.d.ts.map

package/dist/rules/consistent-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-constraints.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQvD,KAAK,UAAU,GACX,2BAA2B,GAC3B,+BAA+B,GAC/B,+BAA+B,GAC/B,0BAA0B,GAC1B,0BAA0B,GAC1B,4BAA4B,GAC5B,gCAAgC,GAChC,2BAA2B,CAAC;AAYhC,eAAO,MAAM,qBAAqB;;CAyLhC,CAAC"}

package/dist/rules/consistent-constraints.js

@@ -0,0 +1,178 @@
+/**
+ * Rule: consistent-constraints
+ *
+ * Ensures constraint decorator pairs have valid ranges and don't conflict:
+ * - @Minimum must be <= @Maximum
+ * - @ExclusiveMinimum must be < @ExclusiveMaximum
+ * - @MinLength must be <= @MaxLength
+ * - @Minimum and @ExclusiveMinimum must not both be present
+ * - @Maximum and @ExclusiveMaximum must not both be present
+ * - @Maximum(n) where n < @Minimum(m) is invalid
+ * - @ExclusiveMaximum(n) where n <= @Minimum(m) is invalid
+ *
+ * Constraints may come from decorators or JSDoc tags. If both a decorator
+ * and a JSDoc tag specify the same constraint, that is a lint error.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { findDecorator, getDecoratorLiteralArg } from "../utils/decorator-utils.js";
+import { getJSDocConstraints, findJSDocConstraint } from "../utils/jsdoc-utils.js";
+const createRule = ESLintUtils.RuleCreator((name) => `https://formspec.dev/eslint-plugin/rules/${name}`);
+export const consistentConstraints = createRule({
+    name: "consistent-constraints",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ensures constraint decorator pairs have valid ranges and don't conflict",
+        },
+        messages: {
+            minimumGreaterThanMaximum: "@Minimum({{min}}) is greater than @Maximum({{max}}). Minimum must be less than or equal to Maximum.",
+            exclusiveMinGreaterOrEqualMax: "@ExclusiveMinimum({{min}}) must be less than @ExclusiveMaximum({{max}}).",
+            minLengthGreaterThanMaxLength: "@MinLength({{min}}) is greater than @MaxLength({{max}}). MinLength must be less than or equal to MaxLength.",
+            conflictingMinimumBounds: "Field has both @Minimum and @ExclusiveMinimum. Use only one lower bound constraint.",
+            conflictingMaximumBounds: "Field has both @Maximum and @ExclusiveMaximum. Use only one upper bound constraint.",
+            exclusiveMaxLessOrEqualMin: "@ExclusiveMaximum({{max}}) must be greater than @Minimum({{min}}).",
+            maximumLessOrEqualExclusiveMin: "@Maximum({{max}}) must be greater than @ExclusiveMinimum({{min}}).",
+            duplicateConstraintSource: "Constraint '{{name}}' is specified via both a decorator and a TSDoc tag. Use one or the other.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            PropertyDefinition(node) {
+                const jsdocConstraints = getJSDocConstraints(node, sourceCode);
+                // Track which constraints have already been reported as duplicates
+                const reportedDuplicates = new Set();
+                /**
+                 * Gets a numeric constraint value from either a decorator or a JSDoc tag.
+                 * Reports a conflict if both sources provide the same constraint.
+                 * Returns null if the constraint is absent, ambiguous, or non-numeric.
+                 */
+                function getConstraintValue(name) {
+                    const dec = findDecorator(node, name);
+                    const jsdoc = findJSDocConstraint(jsdocConstraints, name);
+                    // Conflict: same constraint from both sources
+                    if (dec && jsdoc) {
+                        reportedDuplicates.add(name);
+                        context.report({
+                            node: dec.node,
+                            messageId: "duplicateConstraintSource",
+                            data: { name },
+                        });
+                        return null; // Don't validate range when ambiguous
+                    }
+                    if (dec) {
+                        const val = getDecoratorLiteralArg(dec);
+                        return typeof val === "number" ? { value: val, loc: dec.node.loc } : null;
+                    }
+                    if (jsdoc && typeof jsdoc.value === "number") {
+                        return { value: jsdoc.value, loc: jsdoc.comment.loc };
+                    }
+                    return null;
+                }
+                /**
+                 * Checks whether a constraint is present from either source.
+                 * Only reports duplicate source if not already reported by getConstraintValue.
+                 */
+                function hasConstraint(name) {
+                    const dec = findDecorator(node, name);
+                    const jsdoc = findJSDocConstraint(jsdocConstraints, name);
+                    if (dec && jsdoc && !reportedDuplicates.has(name)) {
+                        reportedDuplicates.add(name);
+                        context.report({
+                            node: dec.node,
+                            messageId: "duplicateConstraintSource",
+                            data: { name },
+                        });
+                    }
+                    if (dec)
+                        return { present: true, loc: dec.node.loc };
+                    if (jsdoc)
+                        return { present: true, loc: jsdoc.comment.loc };
+                    return { present: false, loc: null };
+                }
+                // Check @Minimum/@Maximum range
+                const minimum = getConstraintValue("Minimum");
+                const maximum = getConstraintValue("Maximum");
+                if (minimum && maximum && minimum.value > maximum.value) {
+                    context.report({
+                        loc: minimum.loc,
+                        messageId: "minimumGreaterThanMaximum",
+                        data: {
+                            min: String(minimum.value),
+                            max: String(maximum.value),
+                        },
+                    });
+                }
+                // Check @ExclusiveMinimum/@ExclusiveMaximum range
+                const exclusiveMin = getConstraintValue("ExclusiveMinimum");
+                const exclusiveMax = getConstraintValue("ExclusiveMaximum");
+                if (exclusiveMin && exclusiveMax && exclusiveMin.value >= exclusiveMax.value) {
+                    context.report({
+                        loc: exclusiveMin.loc,
+                        messageId: "exclusiveMinGreaterOrEqualMax",
+                        data: {
+                            min: String(exclusiveMin.value),
+                            max: String(exclusiveMax.value),
+                        },
+                    });
+                }
+                // Check @MinLength/@MaxLength range
+                const minLength = getConstraintValue("MinLength");
+                const maxLength = getConstraintValue("MaxLength");
+                if (minLength && maxLength && minLength.value > maxLength.value) {
+                    context.report({
+                        loc: minLength.loc,
+                        messageId: "minLengthGreaterThanMaxLength",
+                        data: {
+                            min: String(minLength.value),
+                            max: String(maxLength.value),
+                        },
+                    });
+                }
+                // Check conflicting bound types: @Minimum + @ExclusiveMinimum
+                const hasMinimum = hasConstraint("Minimum");
+                const hasExclusiveMinimum = hasConstraint("ExclusiveMinimum");
+                if (hasMinimum.present && hasExclusiveMinimum.present) {
+                    context.report({
+                        loc: hasExclusiveMinimum.loc ?? node.loc,
+                        messageId: "conflictingMinimumBounds",
+                    });
+                }
+                // Check conflicting bound types: @Maximum + @ExclusiveMaximum
+                const hasMaximum = hasConstraint("Maximum");
+                const hasExclusiveMaximum = hasConstraint("ExclusiveMaximum");
+                if (hasMaximum.present && hasExclusiveMaximum.present) {
+                    context.report({
+                        loc: hasExclusiveMaximum.loc ?? node.loc,
+                        messageId: "conflictingMaximumBounds",
+                    });
+                }
+                // Check @ExclusiveMinimum(m) + @Maximum(n) where n <= m
+                if (exclusiveMin && maximum && maximum.value <= exclusiveMin.value) {
+                    context.report({
+                        loc: maximum.loc,
+                        messageId: "maximumLessOrEqualExclusiveMin",
+                        data: {
+                            min: String(exclusiveMin.value),
+                            max: String(maximum.value),
+                        },
+                    });
+                }
+                // Check @ExclusiveMaximum(n) where n <= @Minimum(m)
+                if (minimum && exclusiveMax && exclusiveMax.value <= minimum.value) {
+                    context.report({
+                        loc: exclusiveMax.loc,
+                        messageId: "exclusiveMaxLessOrEqualMin",
+                        data: {
+                            min: String(minimum.value),
+                            max: String(exclusiveMax.value),
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=consistent-constraints.js.map

package/dist/rules/consistent-constraints.js.map

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

package/dist/rules/constraints/allowed-field-types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rule: constraints/allowed-field-types
+ *
+ * Validates that field types used in the Chain DSL are allowed by the
+ * project's constraint configuration.
+ *
+ * Works with: field.text(), field.number(), field.boolean(), field.enum(),
+ * field.dynamicEnum(), field.dynamicSchema(), field.array(), field.object()
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { type FieldTypeConstraints } from "@formspec/constraints/browser";
+export type Options = [FieldTypeConstraints];
+export declare const allowedFieldTypes: ESLintUtils.RuleModule<"disallowedFieldType", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=allowed-field-types.d.ts.map