@neralabs/rerail-pack-javascript 0.1.1

package/rules/eslint-no-dupe-keys.json

@@ -0,0 +1,295 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "eslint-no-dupe-keys",
+  "revision": 6,
+  "mode": "steer",
+  "description": "ESLint 10.11.0 no-dupe-keys, default options. Port of ESLint's `no-dupe-keys` rule (https://eslint.org/docs/latest/rules/no-dupe-keys). Flags an object-literal property whose static key (ESLint's getStaticPropertyName, via `compare` text `key`) repeats an earlier property of the same object; a getter may pair with a setter, and a non-computed `__proto__: value` is not a key.",
+  "scope": {
+    "include": [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.mts",
+      "**/*.cts",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.mjs",
+      "**/*.cjs"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-key",
+      "forbid": {
+        "ast": {
+          "language": "typescript",
+          "rule": {
+            "all": [
+              {
+                "matches": "cand"
+              },
+              {
+                "pattern": "$P"
+              },
+              {
+                "any": [
+                  {
+                    "kind": "shorthand_property_identifier",
+                    "pattern": "$K"
+                  },
+                  {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "matches": "key",
+                      "not": {
+                        "kind": "computed_property_name"
+                      },
+                      "pattern": "$K"
+                    }
+                  },
+                  {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "matches": "key",
+                      "kind": "computed_property_name",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "not": {
+                          "regex": "^[\\[\\]]$"
+                        },
+                        "pattern": "$K"
+                      }
+                    }
+                  }
+                ]
+              },
+              {
+                "any": [
+                  {
+                    "all": [
+                      {
+                        "matches": "getter"
+                      },
+                      {
+                        "count": {
+                          "follows": {
+                            "stopBy": "end",
+                            "all": [
+                              {
+                                "matches": "cand"
+                              },
+                              {
+                                "not": {
+                                  "matches": "setter"
+                                }
+                              }
+                            ],
+                            "pattern": "$Q",
+                            "compare": {
+                              "left": "Q",
+                              "op": "eq",
+                              "right": "P",
+                              "text": "key"
+                            }
+                          },
+                          "min": 1
+                        }
+                      }
+                    ]
+                  },
+                  {
+                    "all": [
+                      {
+                        "matches": "setter"
+                      },
+                      {
+                        "count": {
+                          "follows": {
+                            "stopBy": "end",
+                            "all": [
+                              {
+                                "matches": "cand"
+                              },
+                              {
+                                "not": {
+                                  "matches": "getter"
+                                }
+                              }
+                            ],
+                            "pattern": "$Q",
+                            "compare": {
+                              "left": "Q",
+                              "op": "eq",
+                              "right": "P",
+                              "text": "key"
+                            }
+                          },
+                          "min": 1
+                        }
+                      }
+                    ]
+                  },
+                  {
+                    "all": [
+                      {
+                        "not": {
+                          "matches": "getter"
+                        }
+                      },
+                      {
+                        "not": {
+                          "matches": "setter"
+                        }
+                      },
+                      {
+                        "count": {
+                          "follows": {
+                            "stopBy": "end",
+                            "all": [
+                              {
+                                "matches": "cand"
+                              }
+                            ],
+                            "pattern": "$Q",
+                            "compare": {
+                              "left": "Q",
+                              "op": "eq",
+                              "right": "P",
+                              "text": "key"
+                            }
+                          },
+                          "min": 1
+                        }
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          },
+          "utils": {
+            "cand": {
+              "all": [
+                {
+                  "any": [
+                    {
+                      "kind": "pair"
+                    },
+                    {
+                      "kind": "method_definition"
+                    },
+                    {
+                      "kind": "shorthand_property_identifier"
+                    }
+                  ]
+                },
+                {
+                  "inside": {
+                    "kind": "object",
+                    "stopBy": "neighbor"
+                  }
+                },
+                {
+                  "not": {
+                    "matches": "proto"
+                  }
+                }
+              ]
+            },
+            "getter": {
+              "kind": "method_definition",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "^get$",
+                "not": {
+                  "kind": "property_identifier"
+                }
+              }
+            },
+            "setter": {
+              "kind": "method_definition",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "^set$",
+                "not": {
+                  "kind": "property_identifier"
+                }
+              }
+            },
+            "key": {
+              "any": [
+                {
+                  "kind": "property_identifier"
+                },
+                {
+                  "kind": "string"
+                },
+                {
+                  "kind": "number"
+                },
+                {
+                  "kind": "computed_property_name"
+                }
+              ],
+              "not": {
+                "follows": {
+                  "stopBy": "end",
+                  "regex": "^:$"
+                }
+              }
+            },
+            "proto": {
+              "kind": "pair",
+              "has": {
+                "stopBy": "neighbor",
+                "matches": "key",
+                "any": [
+                  {
+                    "kind": "property_identifier",
+                    "regex": "^__proto__$"
+                  },
+                  {
+                    "kind": "string",
+                    "value": {
+                      "eq": "__proto__"
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "transform": {
+            "KT": {
+              "substring": {
+                "source": "$K",
+                "value": true
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.K",
+        "code": "no-dupe-keys",
+        "message": "Duplicate key '$KT'.",
+        "suppress": {
+          "eslint": {
+            "rules": [
+              "no-dupe-keys"
+            ]
+          },
+          "oxlint": {
+            "rules": [
+              "no-dupe-keys"
+            ]
+          },
+          "biome": {
+            "rules": [
+              "lint/suspicious/noDuplicateObjectKeys"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/eslint-no-duplicate-case.json

@@ -0,0 +1,160 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "eslint-no-duplicate-case",
+  "revision": 4,
+  "mode": "steer",
+  "description": "ESLint 10.11.0 no-duplicate-case, default options. Port of ESLint's `no-duplicate-case` rule (https://eslint.org/docs/latest/rules/no-duplicate-case). Reports a case whose test (inside any parentheses) is token-equal (ESLint's equalTokens, via `compare` text `tokens`) to an earlier case of the same switch.",
+  "scope": {
+    "include": [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.mts",
+      "**/*.cts",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.mjs",
+      "**/*.cjs"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-case",
+      "forbid": {
+        "ast": {
+          "language": "typescript",
+          "rule": {
+            "kind": "switch_case",
+            "all": [
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "not": {
+                    "kind": "comment"
+                  },
+                  "matches": "t",
+                  "precedes": {
+                    "regex": "^:$",
+                    "stopBy": "end"
+                  }
+                }
+              },
+              {
+                "count": {
+                  "follows": {
+                    "stopBy": "end",
+                    "kind": "switch_case",
+                    "all": [
+                      {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "kind": "comment"
+                          },
+                          "matches": "u",
+                          "precedes": {
+                            "regex": "^:$",
+                            "stopBy": "end"
+                          }
+                        }
+                      }
+                    ],
+                    "compare": {
+                      "left": "U",
+                      "op": "eq",
+                      "right": "T",
+                      "text": "tokens"
+                    }
+                  },
+                  "min": 1
+                }
+              }
+            ]
+          },
+          "utils": {
+            "t": {
+              "any": [
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "pattern": "$T"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "all": [
+                      {
+                        "not": {
+                          "kind": "comment"
+                        }
+                      },
+                      {
+                        "not": {
+                          "regex": "^[()]$"
+                        }
+                      }
+                    ],
+                    "matches": "t"
+                  }
+                }
+              ]
+            },
+            "u": {
+              "any": [
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "pattern": "$U"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "all": [
+                      {
+                        "not": {
+                          "kind": "comment"
+                        }
+                      },
+                      {
+                        "not": {
+                          "regex": "^[()]$"
+                        }
+                      }
+                    ],
+                    "matches": "u"
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "no-duplicate-case",
+        "message": "Duplicate case label.",
+        "suppress": {
+          "eslint": {
+            "rules": [
+              "no-duplicate-case"
+            ]
+          },
+          "oxlint": {
+            "rules": [
+              "no-duplicate-case"
+            ]
+          },
+          "biome": {
+            "rules": [
+              "lint/suspicious/noDuplicateCase"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/eslint-no-empty-pattern.json

@@ -0,0 +1 @@
+{"format":"rerail.policy/v1","id":"eslint-no-empty-pattern","revision":4,"mode":"steer","description":"Port of ESLint's `no-empty-pattern` rule (https://eslint.org/docs/latest/rules/no-empty-pattern). Flags empty object and array destructuring patterns. Options are declared in the `options` define (the rule's defaults); a variant is a config patch.","scope":{"include":["**/*"],"exclude":[]},"clauses":[{"id":"options","define":{"options":{"allowObjectPatternsAsParameters":{"type":"boolean","nullable":true,"default":null}}}},{"id":"shared","define":{"language":"typescript","utils":{"r1":{"has":{"all":[{"not":{"kind":"comment"}},{"not":{"regex":"^[{}]$"}}]}},"r2":{"kind":"object_pattern","not":{"matches":"r1"}}}}},{"id":"empty-object-pattern","forbid":{"ast":{"language":"typescript","rule":{"$option":"allowObjectPatternsAsParameters","cases":{"true":{"all":[{"matches":"r2"},{"not":{"inside":{"stopBy":"neighbor","all":[{"any":[{"kind":"required_parameter"},{"kind":"optional_parameter"}]},{"any":[{"not":{"has":{"regex":"^=$"}}},{"has":{"kind":"object","not":{"matches":"r1"}}}]}]}}}]}},"default":{"matches":"r2"}}}},"violation":{"anchor":"witness.span","code":"no-empty-pattern","message":"Unexpected empty object pattern.","suppress":{"eslint":{"rules":["no-empty-pattern"]},"oxlint":{"rules":["no-empty-pattern"]},"biome":{"rules":["lint/correctness/noEmptyPattern"]}}}},{"id":"empty-array-pattern","forbid":{"ast":{"language":"typescript","rule":{"kind":"array_pattern","not":{"has":{"all":[{"not":{"kind":"comment"}},{"not":{"regex":"^[\\[\\]]$"}}]}}}}},"violation":{"anchor":"witness.span","code":"no-empty-pattern","message":"Unexpected empty array pattern.","suppress":{"eslint":{"rules":["no-empty-pattern"]},"oxlint":{"rules":["no-empty-pattern"]},"biome":{"rules":["lint/correctness/noEmptyPattern"]}}}}]}

package/rules/eslint-no-empty-static-block.json

@@ -0,0 +1,64 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "eslint-no-empty-static-block",
+  "revision": 3,
+  "mode": "steer",
+  "description": "Port of ESLint's `no-empty-static-block` rule (https://eslint.org/docs/latest/rules/no-empty-static-block). Reports a class static block with no statements and no comment inside its braces (a trailing comment the grammar attaches after the closing brace does not count).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "empty-static-block",
+      "forbid": {
+        "ast": {
+          "language": "typescript",
+          "rule": {
+            "kind": "statement_block",
+            "inside": {
+              "kind": "class_static_block",
+              "stopBy": "neighbor"
+            },
+            "not": {
+              "has": {
+                "stopBy": "neighbor",
+                "not": {
+                  "regex": "^[{}]$"
+                },
+                "precedes": {
+                  "regex": "^}$",
+                  "stopBy": "end"
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "no-empty-static-block",
+        "message": "Unexpected empty static block.",
+        "suppress": {
+          "eslint": {
+            "rules": [
+              "no-empty-static-block"
+            ]
+          },
+          "oxlint": {
+            "rules": [
+              "no-empty-static-block"
+            ]
+          },
+          "biome": {
+            "rules": [
+              "lint/suspicious/noEmptyBlockStatements"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}