playwright-smart-test 0.0.0-stage → 1.0.2

package/node_modules/glob/src/ignore.ts

@@ -0,0 +1,162 @@
+// give it a pattern, and it'll be able to tell you if
+// a given path should be ignored.
+// Ignoring a path ignores its children if the pattern ends in /**
+// Ignores are always parsed in dot:true mode
+
+import type { MinimatchOptions } from 'minimatch'
+import { escape, Minimatch } from 'minimatch'
+import type { Path } from 'path-scurry'
+import { Pattern } from './pattern.js'
+import type { GlobWalkerOpts } from './walker.js'
+
+export interface IgnoreLike {
+  ignored?: (p: Path) => boolean
+  childrenIgnored?: (p: Path) => boolean
+  add?: (ignore: string) => void
+}
+
+const defaultPlatform: NodeJS.Platform =
+  (
+    typeof process === 'object' &&
+    process &&
+    typeof process.platform === 'string'
+  ) ?
+    process.platform
+  : 'linux'
+
+/**
+ * Class used to process ignored patterns
+ */
+export class Ignore implements IgnoreLike {
+  relative: Minimatch[]
+  relativeChildren: Minimatch[]
+  absolute: Minimatch[]
+  absoluteChildren: Minimatch[]
+  platform: NodeJS.Platform
+  mmopts: MinimatchOptions
+  /**
+   * The escaped glob for the directory that a pattern starting with
+   * `/` is rooted at, with no trailing `/`.
+   */
+  slashRoot: string
+
+  /**
+   * Patterns that start with `/` (but not drive letters or UNC paths
+   * on Windows) start at the `root` option if it is set, or else at
+   * the root of `cwd`, the same as non-ignored patterns. If `cwd` is
+   * not provided, they start at `/`.
+   */
+  constructor(
+    ignored: string[],
+    {
+      nobrace,
+      nocase,
+      noext,
+      noglobstar,
+      normalize,
+      platform = defaultPlatform,
+      root,
+      windowsPathsNoEscape,
+      allowWindowsEscape,
+    }: GlobWalkerOpts,
+    cwd?: Path,
+  ) {
+    this.relative = []
+    this.absolute = []
+    this.relativeChildren = []
+    this.absoluteChildren = []
+    this.platform = platform
+    windowsPathsNoEscape =
+      !!windowsPathsNoEscape || allowWindowsEscape === false
+    this.mmopts = {
+      dot: true,
+      nobrace,
+      nocase,
+      noext,
+      noglobstar,
+      normalize,
+      optimizationLevel: 2,
+      platform,
+      nocomment: true,
+      nonegate: true,
+      windowsPathsNoEscape,
+    }
+    const slashRoot = cwd?.resolve(root ?? '/').fullpath() ?? '/'
+    this.slashRoot = escape(
+      slashRoot.replace(/\\/g, '/').replace(/\/$/, ''),
+      { windowsPathsNoEscape },
+    )
+    for (const ign of ignored) this.add(ign)
+  }
+
+  add(ign: string) {
+    // this is a little weird, but it gives us a clean set of optimized
+    // minimatch matchers, without getting tripped up if one of them
+    // ends in /** inside a brace section, and it's only inefficient at
+    // the start of the walk, not along it.
+    // It'd be nice if the Pattern class just had a .test() method, but
+    // handling globstars is a bit of a pita, and that code already lives
+    // in minimatch anyway.
+    // Another way would be if maybe Minimatch could take its set/globParts
+    // as an option, and then we could at least just use Pattern to test
+    // for absolute-ness.
+    // Yet another way, Minimatch could take an array of glob strings, and
+    // a cwd option, and do the right thing.
+    const mm = new Minimatch(ign, this.mmopts)
+    for (let i = 0; i < mm.set.length; i++) {
+      const parsed = mm.set[i]
+      const globParts = mm.globParts[i]
+      /* c8 ignore start */
+      if (!parsed || !globParts) {
+        throw new Error('invalid pattern object')
+      }
+      // strip off leading ./ portions
+      // https://github.com/isaacs/node-glob/issues/570
+      while (parsed[0] === '.' && globParts[0] === '.') {
+        parsed.shift()
+        globParts.shift()
+      }
+      /* c8 ignore stop */
+      const p = new Pattern(parsed, globParts, 0, this.platform)
+      const glob =
+        p.root() === '/' ?
+          `${this.slashRoot}/${p.rest()?.globString() ?? ''}`
+        : p.globString()
+      const m = new Minimatch(glob, this.mmopts)
+      const children = globParts[globParts.length - 1] === '**'
+      const absolute = p.isAbsolute()
+      if (absolute) this.absolute.push(m)
+      else this.relative.push(m)
+      if (children) {
+        if (absolute) this.absoluteChildren.push(m)
+        else this.relativeChildren.push(m)
+      }
+    }
+  }
+
+  ignored(p: Path): boolean {
+    const fullpath = p.fullpath()
+    const fullpaths = `${fullpath}/`
+    const relative = p.relative() || '.'
+    const relatives = `${relative}/`
+    for (const m of this.relative) {
+      if (m.match(relative) || m.match(relatives)) return true
+    }
+    for (const m of this.absolute) {
+      if (m.match(fullpath) || m.match(fullpaths)) return true
+    }
+    return false
+  }
+
+  childrenIgnored(p: Path): boolean {
+    const fullpath = `${p.fullpath()}/`
+    const relative = `${p.relative() || '.'}/`
+    for (const m of this.relativeChildren) {
+      if (m.match(relative)) return true
+    }
+    for (const m of this.absoluteChildren) {
+      if (m.match(fullpath)) return true
+    }
+    return false
+  }
+}

package/node_modules/glob/src/index.ts

@@ -0,0 +1,225 @@
+import { escape, unescape } from 'minimatch'
+import type { Minipass } from 'minipass'
+import type { Path } from 'path-scurry'
+import type {
+  GlobOptions,
+  GlobOptionsWithFileTypesFalse,
+  GlobOptionsWithFileTypesTrue,
+  GlobOptionsWithFileTypesUnset,
+} from './glob.js'
+import { Glob } from './glob.js'
+import { hasMagic } from './has-magic.js'
+
+export { escape, unescape } from 'minimatch'
+export type { Form } from 'minimatch'
+export type {
+  FSOption,
+  Path,
+  WalkOptions,
+  WalkOptionsWithFileTypesTrue,
+  WalkOptionsWithFileTypesUnset,
+} from 'path-scurry'
+export { Glob } from './glob.js'
+export type {
+  GlobOptions,
+  GlobOptionsWithFileTypesFalse,
+  GlobOptionsWithFileTypesTrue,
+  GlobOptionsWithFileTypesUnset,
+} from './glob.js'
+export { hasMagic } from './has-magic.js'
+export { Ignore } from './ignore.js'
+export type { IgnoreLike } from './ignore.js'
+export type { MatchStream } from './walker.js'
+
+/**
+ * Syncronous form of {@link globStream}. Will read all the matches as fast as
+ * you consume them, even all in a single tick if you consume them immediately,
+ * but will still respond to backpressure if they're not consumed immediately.
+ */
+export function globStreamSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): Minipass<Path, Path>
+export function globStreamSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): Minipass<string, string>
+export function globStreamSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesUnset,
+): Minipass<string, string>
+export function globStreamSync(
+  pattern: string | string[],
+  options: GlobOptions,
+): Minipass<Path, Path> | Minipass<string, string>
+export function globStreamSync(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).streamSync()
+}
+
+/**
+ * Return a stream that emits all the strings or `Path` objects and
+ * then emits `end` when completed.
+ */
+export function globStream(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): Minipass<string, string>
+export function globStream(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): Minipass<Path, Path>
+export function globStream(
+  pattern: string | string[],
+  options?: GlobOptionsWithFileTypesUnset | undefined,
+): Minipass<string, string>
+export function globStream(
+  pattern: string | string[],
+  options: GlobOptions,
+): Minipass<Path, Path> | Minipass<string, string>
+export function globStream(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).stream()
+}
+
+/**
+ * Synchronous form of {@link glob}
+ */
+export function globSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): string[]
+export function globSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): Path[]
+export function globSync(
+  pattern: string | string[],
+  options?: GlobOptionsWithFileTypesUnset | undefined,
+): string[]
+export function globSync(
+  pattern: string | string[],
+  options: GlobOptions,
+): Path[] | string[]
+export function globSync(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).walkSync()
+}
+
+/**
+ * Perform an asynchronous glob search for the pattern(s) specified. Returns
+ * [Path](https://isaacs.github.io/path-scurry/classes/PathBase) objects if the
+ * {@link withFileTypes} option is set to `true`. See {@link GlobOptions} for
+ * full option descriptions.
+ */
+async function glob_(
+  pattern: string | string[],
+  options?: GlobOptionsWithFileTypesUnset | undefined,
+): Promise<string[]>
+async function glob_(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): Promise<Path[]>
+async function glob_(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): Promise<string[]>
+async function glob_(
+  pattern: string | string[],
+  options: GlobOptions,
+): Promise<Path[] | string[]>
+async function glob_(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).walk()
+}
+
+/**
+ * Return a sync iterator for walking glob pattern matches.
+ */
+export function globIterateSync(
+  pattern: string | string[],
+  options?: GlobOptionsWithFileTypesUnset | undefined,
+): Generator<string, void, void>
+export function globIterateSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): Generator<Path, void, void>
+export function globIterateSync(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): Generator<string, void, void>
+export function globIterateSync(
+  pattern: string | string[],
+  options: GlobOptions,
+): Generator<Path, void, void> | Generator<string, void, void>
+export function globIterateSync(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).iterateSync()
+}
+
+/**
+ * Return an async iterator for walking glob pattern matches.
+ */
+export function globIterate(
+  pattern: string | string[],
+  options?: GlobOptionsWithFileTypesUnset | undefined,
+): AsyncGenerator<string, void, void>
+export function globIterate(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesTrue,
+): AsyncGenerator<Path, void, void>
+export function globIterate(
+  pattern: string | string[],
+  options: GlobOptionsWithFileTypesFalse,
+): AsyncGenerator<string, void, void>
+export function globIterate(
+  pattern: string | string[],
+  options: GlobOptions,
+): AsyncGenerator<Path, void, void> | AsyncGenerator<string, void, void>
+export function globIterate(
+  pattern: string | string[],
+  options: GlobOptions = {},
+) {
+  return new Glob(pattern, options).iterate()
+}
+
+// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc
+export const streamSync = globStreamSync
+export const stream = Object.assign(globStream, { sync: globStreamSync })
+export const iterateSync = globIterateSync
+export const iterate = Object.assign(globIterate, {
+  sync: globIterateSync,
+})
+export const sync = Object.assign(globSync, {
+  stream: globStreamSync,
+  iterate: globIterateSync,
+})
+
+export const glob = Object.assign(glob_, {
+  glob: glob_,
+  globSync,
+  sync,
+  globStream,
+  stream,
+  globStreamSync,
+  streamSync,
+  globIterate,
+  iterate,
+  globIterateSync,
+  iterateSync,
+  Glob,
+  hasMagic,
+  escape,
+  unescape,
+})
+glob.glob = glob

package/node_modules/glob/src/pattern.ts

@@ -0,0 +1,286 @@
+// this is just a very light wrapper around 2 arrays with an offset index
+
+import type { ParseReturnFiltered } from 'minimatch'
+import { GLOBSTAR } from 'minimatch'
+
+/**
+ * One portion of a parsed minimatch pattern: a string, a Matcher for
+ * a portion with magic, or GLOBSTAR for `**`.
+ */
+export type MMPattern = ParseReturnFiltered
+
+/** The Matcher that minimatch makes for a portion with magic. */
+export type MMMatcher = Exclude<MMPattern, string | typeof GLOBSTAR>
+
+// an array of length >= 1
+export type PatternList = [p: MMPattern, ...rest: MMPattern[]]
+export type UNCPatternList = [
+  p0: '',
+  p1: '',
+  p2: string,
+  p3: string,
+  ...rest: MMPattern[],
+]
+export type DrivePatternList = [p0: string, ...rest: MMPattern[]]
+export type AbsolutePatternList = [p0: '', ...rest: MMPattern[]]
+export type GlobList = [p: string, ...rest: string[]]
+
+const isPatternList = (pl: MMPattern[]): pl is PatternList =>
+  pl.length >= 1
+const isGlobList = (gl: string[]): gl is GlobList => gl.length >= 1
+
+const customInspect = Symbol.for('nodejs.util.inspect.custom')
+
+/**
+ * An immutable-ish view on an array of glob parts and their parsed
+ * results
+ */
+export class Pattern {
+  readonly #patternList: PatternList
+  readonly #globList: GlobList
+  readonly #index: number
+  readonly length: number
+  readonly #platform: NodeJS.Platform
+  #rest?: Pattern | null
+  #globString?: string
+  #isDrive?: boolean
+  #isUNC?: boolean
+  #isAbsolute?: boolean
+  #followGlobstar: boolean = true
+
+  constructor(
+    patternList: MMPattern[],
+    globList: string[],
+    index: number,
+    platform: NodeJS.Platform,
+  ) {
+    if (!isPatternList(patternList)) {
+      throw new TypeError('empty pattern list')
+    }
+    if (!isGlobList(globList)) {
+      throw new TypeError('empty glob list')
+    }
+    if (globList.length !== patternList.length) {
+      throw new TypeError('mismatched pattern list and glob list lengths')
+    }
+    this.length = patternList.length
+    if (index < 0 || index >= this.length) {
+      throw new TypeError('index out of range')
+    }
+    this.#patternList = patternList
+    this.#globList = globList
+    this.#index = index
+    this.#platform = platform
+
+    // normalize root entries of absolute patterns on initial creation.
+    if (this.#index === 0) {
+      // c: => ['c:/']
+      // C:/ => ['C:/']
+      // C:/x => ['C:/', 'x']
+      // //host/share => ['//host/share/']
+      // //host/share/ => ['//host/share/']
+      // //host/share/x => ['//host/share/', 'x']
+      // //?/UNC/host/share/x => ['//?/UNC/host/share/', 'x']
+      // /etc => ['/', 'etc']
+      // / => ['/']
+      if (this.isUNC()) {
+        // '' / '' / 'host' / 'share', or
+        // '' / '' / '?' / 'UNC' / 'host' / 'share'
+        const n = this.#isLongUNC() ? 6 : 4
+        const proot = this.#patternList.slice(0, n)
+        const groot = this.#globList.slice(0, n)
+        const prest = this.#patternList.slice(n)
+        const grest = this.#globList.slice(n)
+        if (prest[0] === '') {
+          // ends in /
+          prest.shift()
+          grest.shift()
+        }
+        const p = [...proot, ''].join('/')
+        const g = [...groot, ''].join('/')
+        this.#patternList = [p, ...prest]
+        this.#globList = [g, ...grest]
+        this.length = this.#patternList.length
+      } else if (this.isDrive() || this.isAbsolute()) {
+        const [p1, ...prest] = this.#patternList
+        const [g1, ...grest] = this.#globList
+        if (prest[0] === '') {
+          // ends in /
+          prest.shift()
+          grest.shift()
+        }
+        const p = `${p1 as string}/`
+        const g = `${g1}/`
+        this.#patternList = [p, ...prest]
+        this.#globList = [g, ...grest]
+        this.length = this.#patternList.length
+      }
+    }
+  }
+
+  [customInspect]() {
+    return `Pattern <${this.#globList.slice(this.#index).join('/')}>`
+  }
+
+  /**
+   * The first entry in the parsed list of patterns
+   */
+  pattern(): MMPattern {
+    return this.#patternList[this.#index] as MMPattern
+  }
+
+  /**
+   * true of if pattern() returns a string
+   */
+  isString(): boolean {
+    return typeof this.#patternList[this.#index] === 'string'
+  }
+  /**
+   * true of if pattern() returns GLOBSTAR
+   */
+  isGlobstar(): boolean {
+    return this.#patternList[this.#index] === GLOBSTAR
+  }
+  /**
+   * true if pattern() returns a Matcher, for a portion with magic
+   */
+  isMatcher(): boolean {
+    return typeof this.#patternList[this.#index] === 'object'
+  }
+
+  /**
+   * The /-joined set of glob parts that make up this pattern
+   */
+  globString(): string {
+    return (this.#globString =
+      this.#globString ||
+      (this.#index === 0 ?
+        this.isAbsolute() ?
+          this.#globList[0] + this.#globList.slice(1).join('/')
+        : this.#globList.join('/')
+      : this.#globList.slice(this.#index).join('/')))
+  }
+
+  /**
+   * true if there are more pattern parts after this one
+   */
+  hasMore(): boolean {
+    return this.length > this.#index + 1
+  }
+
+  /**
+   * The rest of the pattern after this part, or null if this is the end
+   */
+  rest(): Pattern | null {
+    if (this.#rest !== undefined) return this.#rest
+    if (!this.hasMore()) return (this.#rest = null)
+    this.#rest = new Pattern(
+      this.#patternList,
+      this.#globList,
+      this.#index + 1,
+      this.#platform,
+    )
+    this.#rest.#isAbsolute = this.#isAbsolute
+    this.#rest.#isUNC = this.#isUNC
+    this.#rest.#isDrive = this.#isDrive
+    return this.#rest
+  }
+
+  // the root is //?/UNC/host/share, the same as //host/share
+  #isLongUNC(): boolean {
+    const pl = this.#patternList
+    return (
+      pl[2] === '?' && typeof pl[3] === 'string' && /^unc$/i.test(pl[3])
+    )
+  }
+
+  /**
+   * true if the pattern represents a //unc/path/ on windows
+   */
+  isUNC(): boolean {
+    const pl = this.#patternList
+    // the host and share, after //?/UNC/ in a long UNC path
+    const h = this.#isLongUNC() ? 4 : 2
+    return this.#isUNC !== undefined ?
+        this.#isUNC
+      : (this.#isUNC =
+          this.#platform === 'win32' &&
+          this.#index === 0 &&
+          pl[0] === '' &&
+          pl[1] === '' &&
+          typeof pl[h] === 'string' &&
+          !!pl[h] &&
+          typeof pl[h + 1] === 'string' &&
+          !!pl[h + 1])
+  }
+
+  // pattern like C:/...
+  // split = ['C:', ...]
+  // XXX: would be nice to handle patterns like `c:*` to test the cwd
+  // in c: for *, but I don't know of a way to even figure out what that
+  // cwd is without actually chdir'ing into it?
+  /**
+   * True if the pattern starts with a drive letter on Windows
+   */
+  isDrive(): boolean {
+    const pl = this.#patternList
+    return this.#isDrive !== undefined ?
+        this.#isDrive
+      : (this.#isDrive =
+          this.#platform === 'win32' &&
+          this.#index === 0 &&
+          this.length > 1 &&
+          typeof pl[0] === 'string' &&
+          /^[a-z]:$/i.test(pl[0]))
+  }
+
+  // pattern = '/' or '/...' or '/x/...'
+  // split = ['', ''] or ['', ...] or ['', 'x', ...]
+  // Drive and UNC both considered absolute on windows
+  /**
+   * True if the pattern is rooted on an absolute path
+   */
+  isAbsolute(): boolean {
+    const pl = this.#patternList
+    return this.#isAbsolute !== undefined ?
+        this.#isAbsolute
+      : (this.#isAbsolute =
+          (pl[0] === '' && pl.length > 1) ||
+          this.isDrive() ||
+          this.isUNC())
+  }
+
+  /**
+   * consume the root of the pattern, and return it
+   */
+  root(): string {
+    const p = this.#patternList[0]
+    return (
+        typeof p === 'string' && this.isAbsolute() && this.#index === 0
+      ) ?
+        p
+      : ''
+  }
+
+  /**
+   * Check to see if the current globstar pattern is allowed to follow
+   * a symbolic link.
+   */
+  checkFollowGlobstar(): boolean {
+    return !(
+      this.#index === 0 ||
+      !this.isGlobstar() ||
+      !this.#followGlobstar
+    )
+  }
+
+  /**
+   * Mark that the current globstar pattern is following a symbolic link
+   */
+  markFollowGlobstar(): boolean {
+    if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)
+      return false
+    this.#followGlobstar = false
+    return true
+  }
+}