@formspec/eslint-plugin 0.1.0-alpha.3

package/README.md

@@ -0,0 +1,217 @@
+# @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,57 @@
+/**
+ * @formspec/eslint-plugin
+ *
+ * ESLint plugin for FormSpec decorator DSL type safety.
+ *
+ * Provides rules to catch common mistakes when using FormSpec decorators:
+ * - Type mismatches between decorators and field types
+ * - Invalid enum option configurations
+ * - Missing or invalid @ShowWhen references
+ * - Conflicting or duplicate decorators
+ */
+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 { minMaxValidRange } from "./rules/min-max-valid-range.js";
+import { noConflictingDecorators } from "./rules/no-conflicting-decorators.js";
+import { noDuplicateDecorators } from "./rules/no-duplicate-decorators.js";
+/**
+ * The FormSpec ESLint plugin.
+ */
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        readonly "decorator-field-type-mismatch": TSESLint.RuleModule<"minMaxOnNonNumber" | "minMaxItemsOnNonArray" | "placeholderOnNonString", [], 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 "min-max-valid-range": TSESLint.RuleModule<"minGreaterThanMax" | "minItemsGreaterThanMaxItems", [], 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;
+        };
+    };
+    configs: {
+        recommended: TSESLint.FlatConfig.ConfigArray;
+        strict: TSESLint.FlatConfig.ConfigArray;
+    };
+};
+export default plugin;
+export { decoratorFieldTypeMismatch, enumOptionsMatchType, showwhenFieldExists, showwhenSuggestsOptional, minMaxValidRange, noConflictingDecorators, noDuplicateDecorators, };
+//# 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;;;;;;;;;;GAUG;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,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AA6E3E;;GAEG;AACH,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOX,CAAC;AAEF,eAAe,MAAM,CAAC;AAGtB,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,GACtB,CAAC"}

package/dist/index.js

@@ -0,0 +1,104 @@
+/**
+ * @formspec/eslint-plugin
+ *
+ * ESLint plugin for FormSpec decorator DSL type safety.
+ *
+ * Provides rules to catch common mistakes when using FormSpec decorators:
+ * - Type mismatches between decorators and field types
+ * - Invalid enum option configurations
+ * - Missing or invalid @ShowWhen references
+ * - Conflicting or duplicate decorators
+ */
+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 { minMaxValidRange } from "./rules/min-max-valid-range.js";
+import { noConflictingDecorators } from "./rules/no-conflicting-decorators.js";
+import { noDuplicateDecorators } from "./rules/no-duplicate-decorators.js";
+/**
+ * All rules provided by this plugin.
+ */
+const rules = {
+    "decorator-field-type-mismatch": decoratorFieldTypeMismatch,
+    "enum-options-match-type": enumOptionsMatchType,
+    "showwhen-field-exists": showwhenFieldExists,
+    "showwhen-suggests-optional": showwhenSuggestsOptional,
+    "min-max-valid-range": minMaxValidRange,
+    "no-conflicting-decorators": noConflictingDecorators,
+    "no-duplicate-decorators": noDuplicateDecorators,
+};
+/**
+ * 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/min-max-valid-range": "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/min-max-valid-range": "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 { decoratorFieldTypeMismatch, enumOptionsMatchType, showwhenFieldExists, showwhenSuggestsOptional, minMaxValidRange, noConflictingDecorators, noDuplicateDecorators, };
+//# 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;;;;;;;;;;GAUG;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,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAE3E;;GAEG;AACH,MAAM,KAAK,GAAG;IACZ,+BAA+B,EAAE,0BAA0B;IAC3D,yBAAyB,EAAE,oBAAoB;IAC/C,uBAAuB,EAAE,mBAAmB;IAC5C,4BAA4B,EAAE,wBAAwB;IACtD,qBAAqB,EAAE,gBAAgB;IACvC,2BAA2B,EAAE,uBAAuB;IACpD,yBAAyB,EAAE,qBAAqB;CACxC,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,+BAA+B,EAAE,OAAO;YACxC,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,+BAA+B,EAAE,OAAO;YACxC,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,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,GACtB,CAAC"}

package/dist/rules/decorator-field-type-mismatch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rule: decorator-field-type-mismatch
+ *
+ * Ensures FormSpec decorators are applied to fields with compatible types:
+ * - @Min/@Max only on number fields
+ * - @MinItems/@MaxItems only on array fields
+ * - @Placeholder only on string fields
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+type MessageIds = "minMaxOnNonNumber" | "minMaxItemsOnNonArray" | "placeholderOnNonString";
+export declare const decoratorFieldTypeMismatch: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};
+//# sourceMappingURL=decorator-field-type-mismatch.d.ts.map

package/dist/rules/decorator-field-type-mismatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator-field-type-mismatch.d.ts","sourceRoot":"","sources":["../../src/rules/decorator-field-type-mismatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAkB,MAAM,0BAA0B,CAAC;AAgBvE,KAAK,UAAU,GACX,mBAAmB,GACnB,uBAAuB,GACvB,wBAAwB,CAAC;AAmB7B,eAAO,MAAM,0BAA0B;;CAoErC,CAAC"}

package/dist/rules/decorator-field-type-mismatch.js

@@ -0,0 +1,87 @@
+/**
+ * Rule: decorator-field-type-mismatch
+ *
+ * Ensures FormSpec decorators are applied to fields with compatible types:
+ * - @Min/@Max only on number fields
+ * - @MinItems/@MaxItems only on array fields
+ * - @Placeholder only on string fields
+ */
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { getFormSpecDecorators, DECORATOR_TYPE_HINTS, } from "../utils/decorator-utils.js";
+import { getPropertyType, getFieldTypeCategory, } from "../utils/type-utils.js";
+const createRule = ESLintUtils.RuleCreator((name) => `https://formspec.dev/eslint-plugin/rules/${name}`);
+const EXPECTED_TYPES = {
+    Min: ["number"],
+    Max: ["number"],
+    Placeholder: ["string"],
+    MinItems: ["array"],
+    MaxItems: ["array"],
+    EnumOptions: ["string", "union"], // Handled by separate rule
+};
+const DECORATOR_MESSAGE_IDS = {
+    Min: "minMaxOnNonNumber",
+    Max: "minMaxOnNonNumber",
+    Placeholder: "placeholderOnNonString",
+    MinItems: "minMaxItemsOnNonArray",
+    MaxItems: "minMaxItemsOnNonArray",
+};
+export const decoratorFieldTypeMismatch = createRule({
+    name: "decorator-field-type-mismatch",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ensures FormSpec decorators are applied to fields with compatible types",
+        },
+        messages: {
+            minMaxOnNonNumber: "@{{decorator}} can only be used on number fields, but field '{{field}}' has type '{{actualType}}'",
+            minMaxItemsOnNonArray: "@{{decorator}} can only be used on array fields, but field '{{field}}' has type '{{actualType}}'",
+            placeholderOnNonString: "@Placeholder can only be used on string fields, but field '{{field}}' has type '{{actualType}}'",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            PropertyDefinition(node) {
+                const decorators = getFormSpecDecorators(node);
+                if (decorators.length === 0)
+                    return;
+                const type = getPropertyType(node, services);
+                if (!type)
+                    return;
+                const fieldTypeCategory = getFieldTypeCategory(type, checker);
+                const fieldName = node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : "<computed>";
+                const actualType = checker.typeToString(type);
+                for (const decorator of decorators) {
+                    const decoratorName = decorator.name;
+                    // Skip decorators that don't have type hints
+                    if (!(decoratorName in DECORATOR_TYPE_HINTS))
+                        continue;
+                    // Skip EnumOptions - handled by separate rule
+                    if (decoratorName === "EnumOptions")
+                        continue;
+                    const expectedTypes = EXPECTED_TYPES[decoratorName];
+                    // Check if field type matches any expected type
+                    const isCompatible = expectedTypes.includes(fieldTypeCategory);
+                    if (!isCompatible) {
+                        const messageId = DECORATOR_MESSAGE_IDS[decoratorName];
+                        if (!messageId)
+                            continue;
+                        context.report({
+                            node: decorator.node,
+                            messageId,
+                            data: {
+                                decorator: decoratorName,
+                                field: fieldName,
+                                actualType,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=decorator-field-type-mismatch.js.map

package/dist/rules/decorator-field-type-mismatch.js.map

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

package/dist/rules/enum-options-match-type.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Rule: enum-options-match-type
+ *
+ * Ensures @EnumOptions values match the field's TypeScript type.
+ *
+ * Valid:
+ *   @EnumOptions(["a", "b", "c"])
+ *   field!: "a" | "b" | "c";
+ *
+ *   @EnumOptions([{ id: "x", label: "X" }])
+ *   field!: "x";
+ *
+ *   @EnumOptions(["a", "b"])
+ *   field!: string;  // Permissive - string accepts any enum
+ *
+ * Invalid:
+ *   @EnumOptions(["a", "b", "c"])
+ *   field!: "x" | "y";  // Mismatch
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+type MessageIds = "enumOptionsMismatch" | "enumOptionsMissing" | "enumOptionsExtra";
+export declare const enumOptionsMatchType: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};
+//# sourceMappingURL=enum-options-match-type.d.ts.map

package/dist/rules/enum-options-match-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-options-match-type.d.ts","sourceRoot":"","sources":["../../src/rules/enum-options-match-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAevD,KAAK,UAAU,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,kBAAkB,CAAC;AAEpF,eAAO,MAAM,oBAAoB;;CAqG/B,CAAC"}

package/dist/rules/enum-options-match-type.js

@@ -0,0 +1,115 @@
+/**
+ * Rule: enum-options-match-type
+ *
+ * Ensures @EnumOptions values match the field's TypeScript type.
+ *
+ * Valid:
+ *   @EnumOptions(["a", "b", "c"])
+ *   field!: "a" | "b" | "c";
+ *
+ *   @EnumOptions([{ id: "x", label: "X" }])
+ *   field!: "x";
+ *
+ *   @EnumOptions(["a", "b"])
+ *   field!: string;  // Permissive - string accepts any enum
+ *
+ * Invalid:
+ *   @EnumOptions(["a", "b", "c"])
+ *   field!: "x" | "y";  // Mismatch
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { findDecorator, getDecoratorArrayArg, } from "../utils/decorator-utils.js";
+import { getPropertyType, getStringLiteralUnionValues, isStringType, } from "../utils/type-utils.js";
+const createRule = ESLintUtils.RuleCreator((name) => `https://formspec.dev/eslint-plugin/rules/${name}`);
+export const enumOptionsMatchType = createRule({
+    name: "enum-options-match-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ensures @EnumOptions values match the field's TypeScript union type",
+        },
+        messages: {
+            enumOptionsMismatch: "@EnumOptions values don't match field type. Options: [{{options}}], Type: {{fieldType}}",
+            enumOptionsMissing: "@EnumOptions is missing values that are in the field type: [{{missing}}]",
+            enumOptionsExtra: "@EnumOptions has values not in the field type: [{{extra}}]",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            PropertyDefinition(node) {
+                const enumOptionsDecorator = findDecorator(node, "EnumOptions");
+                if (!enumOptionsDecorator)
+                    return;
+                const type = getPropertyType(node, services);
+                if (!type)
+                    return;
+                // If field type is plain `string`, any enum options are valid
+                if (isStringType(type, checker) && !type.isUnion()) {
+                    return;
+                }
+                // Get the enum option values from the decorator
+                const decoratorValues = getDecoratorArrayArg(enumOptionsDecorator);
+                if (!decoratorValues)
+                    return;
+                // Extract IDs from decorator options
+                const optionIds = new Set();
+                for (const value of decoratorValues) {
+                    if (typeof value === "string") {
+                        optionIds.add(value);
+                    }
+                    else if (typeof value === "object" && value !== null && "id" in value) {
+                        const id = value.id;
+                        if (typeof id === "string") {
+                            optionIds.add(id);
+                        }
+                    }
+                }
+                // Get the union type values from the field type
+                const typeValues = getStringLiteralUnionValues(type, checker);
+                if (!typeValues) {
+                    // Field type is not a string literal union - can't compare
+                    return;
+                }
+                const typeSet = new Set(typeValues);
+                // Find missing values (in type but not in options)
+                const missing = [];
+                for (const v of typeValues) {
+                    if (!optionIds.has(v)) {
+                        missing.push(v);
+                    }
+                }
+                // Find extra values (in options but not in type)
+                const extra = [];
+                for (const v of optionIds) {
+                    if (!typeSet.has(v)) {
+                        extra.push(v);
+                    }
+                }
+                // Report specific issues
+                if (missing.length > 0) {
+                    context.report({
+                        node: enumOptionsDecorator.node,
+                        messageId: "enumOptionsMissing",
+                        data: {
+                            missing: missing.map((v) => `"${v}"`).join(", "),
+                        },
+                    });
+                }
+                if (extra.length > 0) {
+                    context.report({
+                        node: enumOptionsDecorator.node,
+                        messageId: "enumOptionsExtra",
+                        data: {
+                            extra: extra.map((v) => `"${v}"`).join(", "),
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enum-options-match-type.js.map

package/dist/rules/enum-options-match-type.js.map

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

package/dist/rules/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * All FormSpec ESLint rules.
+ */
+export { decoratorFieldTypeMismatch } from "./decorator-field-type-mismatch.js";
+export { enumOptionsMatchType } from "./enum-options-match-type.js";
+export { showwhenFieldExists } from "./showwhen-field-exists.js";
+export { showwhenSuggestsOptional } from "./showwhen-suggests-optional.js";
+export { minMaxValidRange } from "./min-max-valid-range.js";
+export { noConflictingDecorators } from "./no-conflicting-decorators.js";
+export { noDuplicateDecorators } from "./no-duplicate-decorators.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}