feat(matcher): ignore patterns

packages/matcher/src/index.ts

@@ -1,16 +1,31 @@
 import escapeStringRegexp from 'escape-string-regexp'
 
-export default function matcher (patterns: string[] | string) {
-  if (typeof patterns === 'string') return matcherFromPattern(patterns)
+type Matcher = (input: string) => boolean
+
+export default function matcher (patterns: string[] | string): Matcher {
+  if (typeof patterns === 'string') return matcherWhenOnlyOnePattern(patterns)
   switch (patterns.length) {
   case 0: return () => false
-  case 1: return matcherFromPattern(patterns[0])
+  case 1: return matcherWhenOnlyOnePattern(patterns[0])
   }
-  const matchArr = patterns.map(matcherFromPattern)
-  return (input: string) => matchArr.some((match) => match(input))
+  return (input: string) => patterns.reduce((result, pattern) => {
+    if (isIgnorePattern(pattern)) {
+      const match = matcherFromPattern(pattern.substring(1))
+      if (match(input)) {
+        return false
+      }
+    } else {
+      const match = matcherFromPattern(pattern)
+      if (match(input)) {
+        return true
+      }
+    }
+
+    return result
+  }, false)
 }
 
-function matcherFromPattern (pattern: string) {
+function matcherFromPattern (pattern: string): Matcher {
   if (pattern === '*') {
     return () => true
   }
@@ -23,3 +38,13 @@ function matcherFromPattern (pattern: string) {
   const regexp = new RegExp(`^${escapedPattern}$`)
   return (input: string) => regexp.test(input)
 }
+
+function isIgnorePattern (pattern: string): boolean {
+  return pattern.startsWith('!')
+}
+
+function matcherWhenOnlyOnePattern (pattern: string): Matcher {
+  return isIgnorePattern(pattern)
+    ? () => false
+    : matcherFromPattern(pattern)
+}