@hublo/sentinel 1.2.0-alpha.3 → 1.2.0-alpha.31

package/plugins/hublo.js

@@ -10,6 +10,12 @@
  * sentinel exists to remove. The cost is that `@hublo/sentinel` carries a rule about Hublo's
  * colour palette, which is honest for a package named after the company.
  *
+ * It now hosts a SECOND, unrelated rule. `no-regex-lookbehind` is not a carried-over selector
+ * but a browser-support rule: regex lookbehind is Safari 16.4+, and unlike everything else a
+ * preset controls it can be neither transpiled nor polyfilled, because no bundler rewrites the
+ * contents of a regex literal. It is here for the same reason as the palette rule — a house
+ * rule is code, not configuration — and because lint is the only layer left that can catch it.
+ *
  * The original selectors, and where each is handled below:
  *   1-2  MemberExpression[object.property.name='palette'][property.name='common']       theme.palette.common
  *        …[computed=true][property.value='common']                                      theme.palette['common']
@@ -25,6 +31,15 @@ const MESSAGE =
 const COLOUR_PROPS =
   /^(color|bgcolor|background|backgroundColor|borderColor|borderTopColor|borderRightColor|borderBottomColor|borderLeftColor|outlineColor|fill|stroke|textDecorationColor|caretColor|accentColor)$/
 
+/**
+ * Lookbehind, positive or negative. NOT named groups `(?<name>)`, which Safari has had since
+ * 11.3: the class is exactly `(?<` followed by `=` or `!`.
+ */
+const LOOKBEHIND = /\(\?<[=!]/
+
+const LOOKBEHIND_MESSAGE =
+  'Regex lookbehind ((?<=) / (?<!)) is Safari 16.4+ and can be neither transpiled nor polyfilled: on older iOS the literal is a parse-time SyntaxError that takes the whole chunk with it. Rewrite the pattern. Named groups (?<name>) are fine.'
+
 /** `common.something` as a string value, e.g. `{ color: 'common.white' }`. */
 const isCommonPath = (node) =>
   node?.type === 'Literal' && typeof node.value === 'string' && /^common\./.test(node.value)
@@ -82,6 +97,59 @@ const plugin = {
         }
       },
     },
+
+    'no-regex-lookbehind': {
+      meta: {
+        docs: {
+          description: 'Ban regex lookbehind, unsupported by Safari below 16.4.',
+        },
+      },
+      create(context) {
+        const report = (node) => context.report({ node, message: LOOKBEHIND_MESSAGE })
+
+        /**
+         * `new RegExp(...)` and `RegExp(...)`, when the pattern is readable statically: a
+         * string, or a template whose fixed parts carry the lookbehind.
+         *
+         * Each template chunk is tested on its own rather than joined. Joining invents a
+         * `(?<=` that the runtime string never has, across an interpolation boundary:
+         * `` `(?<${op}=x)` `` would read as one.
+         */
+        const isStaticLookbehind = (pattern) => {
+          if (pattern?.type === 'Literal') {
+            return typeof pattern.value === 'string' && LOOKBEHIND.test(pattern.value)
+          }
+          if (pattern?.type === 'TemplateLiteral') {
+            return (pattern.quasis ?? []).some((quasi) =>
+              LOOKBEHIND.test(quasi.value?.cooked ?? quasi.value?.raw ?? ''),
+            )
+          }
+          return false
+        }
+
+        const checkRegExpCall = (node) => {
+          if (node.callee?.name !== 'RegExp') {
+            return
+          }
+          const pattern = node.arguments?.[0]
+          if (isStaticLookbehind(pattern)) {
+            report(pattern)
+          }
+        }
+
+        return {
+          // The case that actually breaks a page: a literal is an EARLY error, so the whole
+          // chunk fails to parse rather than the one call site failing.
+          Literal(node) {
+            if (node.regex && LOOKBEHIND.test(node.regex.pattern)) {
+              report(node)
+            }
+          },
+          NewExpression: checkRegExpCall,
+          CallExpression: checkRegExpCall,
+        }
+      },
+    },
   },
 }