@vltpkg/query 1.5.0 → 1.6.1

package/test/pseudo.ts

@@ -1,584 +0,0 @@
-import t from 'tap'
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import { pseudoClassNames } from '@vltpkg/dss-parser'
-import { pseudo, pseudoSelectorNames } from '../src/pseudo.ts'
-import {
-  getCycleGraph,
-  getMissingManifestsGraph,
-  getMissingNodeGraph,
-  getMultiWorkspaceGraph,
-  getSimpleGraph,
-  getSingleWorkspaceGraph,
-  getPathBasedGraph,
-} from './fixtures/graph.ts'
-import {
-  copyGraphSelectionState,
-  getGraphSelectionState,
-  selectorFixture,
-} from './fixtures/selector.ts'
-import type { PostcssNodeWithChildren } from '@vltpkg/dss-parser'
-import type { TestCase } from './fixtures/types.ts'
-import type {
-  GraphSelectionState,
-  ParserState,
-} from '../src/types.ts'
-
-const testPseudo = selectorFixture(pseudo)
-
-t.test('pseudo', async t => {
-  const simpleGraph = getSimpleGraph()
-  const all = {
-    edges: new Set(simpleGraph.edges),
-    nodes: new Set(simpleGraph.nodes.values()),
-  }
-  const a = getGraphSelectionState(simpleGraph, 'a')
-  const b = getGraphSelectionState(simpleGraph, 'b')
-  const d = getGraphSelectionState(simpleGraph, 'd')
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-  const queryToExpected = new Set<TestCase>([
-    [':root', all, ['my-project']], // from initial nodes
-    [':root', empty, []], // from empty nodes
-    [':root', b, []], // from diff node
-    [':project /*all*/', all, ['my-project']], // no workspaces in graph
-    [':project /*empty*/', empty, []], // from empty nodes
-    [':project /*b*/', b, []], // from diff node
-    [':scope', all, ['my-project']], // :scope refers to the initial values from initial
-    [':scope', b, []], // :scope resets the initial values from a partial
-    [':scope', empty, []], // :scope resets the initial values from empty partial
-    // :attr selector
-    [':attr([scripts])', all, ['b']], // prop lookup only
-    [':attr([scripts])', b, ['b']], // start with a single node
-    [':attr([scripts])', a, []], // unmatching single node
-    [':attr([scripts])', empty, []], // starting from empty
-    [':attr([bolinha])', all, []], // missing property
-    [':attr(a, e, [bolinha])', all, []], // fail to match something in an array of strings
-    [':attr(a, e, [bar])', all, []], // attr key can not match array items
-    [':attr(a, [e])', all, ['d']], // match something in an array of strings
-    [':attr(a, [e=bar])', all, ['d']], // match something in an array of strings
-    [':attr(a, [e=foo])', all, ['d']], // match something in an array of strings
-    [':attr([keywords=something])', all, ['c']], // match something in an array of strings
-    [':attr([keywords=missing])', all, []], // can not match missing item in array
-    [':attr(a, [e=baz])', all, []], // match something missing in an array of strings
-    [':attr(foo, bar, [baz])', all, []], // multiple missing properties
-    [':attr(scripts, [baz])', all, []], // mixed missing properties
-    [':attr(scripts, bar, [baz])', all, []], // mixed missing properties
-    [':attr(scripts, [postinstall])', all, ['b']], // nested prop
-    [':attr(scripts, [test=test])', all, ['b']], // nested prop match
-    [':attr(contributors, [name^=Ruy])', all, ['b']], // nested array
-    [
-      ':attr(contributors, [email=ruyadorno@example.com])',
-      all,
-      ['b'],
-    ],
-    [':attr([peerDependenciesMeta])', all, ['c']],
-    [':attr(peerDependenciesMeta, [foo])', all, ['c']],
-    [':attr(peerDependenciesMeta, foo, [optional])', all, ['c']], // 2-lvls
-    [':attr(peerDependenciesMeta, foo, [optional=true])', all, ['c']],
-    [':attr([a])', all, ['d']], // nested props start
-    [':attr(a, [b])', all, ['d']], // nested props
-    [':attr(a, b, [c])', all, ['d']], // nested props within array
-    [':attr(a, b, c, [d])', all, ['d']], // nested props within array
-    [':attr(a, b, c, [d=foo])', all, ['d']], // nested props within array
-    [':attr(a, b, c, [d=bar])', all, ['d']], // nested props within array
-    [
-      ':attr([name])',
-      all,
-      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // nested props within array
-    [
-      ':attr([version^=1])',
-      all,
-      ['my-project', 'a', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // nested props within array
-    [':empty', all, ['a', 'c', 'e', 'f', '@x/y']], // deps with no deps
-    [':empty', a, ['a']], // single :empty item
-    [':empty', b, []], // single not :empty item
-    [':empty', empty, []], // no items to filter
-    [':has(*)', all, ['my-project', 'b', 'd']], // has any sub selector matches, e.g: children
-    [':has(*)', b, ['b']], // has any sub selector matches, e.g: children
-    [':has(> *)', all, ['my-project', 'b', 'd']], // has any sub selector matches, e.g: children
-    [':has(> *)', b, ['b']], // has any sub selector matches, e.g: children
-    [':has([name=e])', all, ['my-project', 'd']], // has any sub selector matches, e.g: children
-    [':has(* [name=e])', all, ['my-project', 'd']], // has any sub selector matches, e.g: children
-    [':has(* > [name=e])', all, ['my-project', 'd']], // has any sub selector matches, e.g: children
-    [':has(* > * > [name=f])', all, ['d']], // has any sub selector matches, e.g: children
-    [':has([name=c], [name=f])', all, ['b', 'd']], // multi sub selectors
-    [':has([name=c], [name=f])', b, ['b']], // multi sub selectors, selecting from single item
-    [':has([name=c], [name=f])', empty, []], // multi sub selectors, selecting from no item
-    [':has(*[nonexistingattribute])', all, []], // nothing to match
-    [':has(~ :attr([peerDependenciesMeta]))', all, ['b']], // has any sub selector matches, e.g: children
-    [':has(:attr([scripts]))', all, ['my-project']], // has child prop lookup
-    [':has(:type(workspace))', all, []], // has no result
-    [':is(:root)', all, ['my-project']], // can match a single node
-    [':is([name=a], [name=b], [name=f])', all, ['a', 'b', 'f']], // can match multiple nodes
-    [':is(:root)', empty, []], // can't match from empty partial
-    [
-      ':is(#foo, [name===z], :root +, :nonexistingselector)',
-      all,
-      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // ignore any invalid selectors on loose mode
-    [':is(:foo)', all, []], // broken selectors fail to match items when in loose mode
-    [':is([name=a], [name=b], [name=f])', empty, []], // can match multiple nodes if no partial
-    [':missing', all, []], // no dangling edges in this graph
-    [':not(:root)', all, ['a', 'b', 'c', 'd', 'e', 'f', '@x/y']], // can negate single node
-    [
-      ':not([name=a], [name=b], [name=f])',
-      all,
-      ['my-project', 'c', 'd', 'e', '@x/y'],
-    ], // can negate multiple selectors
-    [':not(:root)', empty, []], // can't negate from empty partial
-    [':not([name=a], [name=b], [name=f])', empty, []], // can negate multiple nodes if no partial
-    [':private', all, ['d']], // private dep
-    [':private', d, ['d']], // single :private item
-    [':private', b, []], // single not :private item
-    [':private', empty, []], // no items to filter
-    [':semver(^2)', all, ['b']], // semver selector
-    [':semver(=2.0.0)', all, ['b']], // semver selector
-    [
-      ':semver("<2.0.0")',
-      all,
-      ['my-project', 'a', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // quoted semver selector
-    [':type(file)', all, ['my-project', '@x/y']], // type selector
-    [':type(git)', all, []], // type selector, no matches
-    [':type(registry)', all, ['a', 'b', 'c', 'd', 'e', 'f']], // type selector, no matches
-    [':type(registry)', empty, []], // type selector, nothing to match
-    [':dev', all, ['b', '@x/y']], // select dev deps
-    [':dev', b, ['b']], // single item dev dep
-    [':dev', empty, []], // empty starting partial
-  ])
-  const initial = copyGraphSelectionState(all)
-  for (const [query, partial, expected] of queryToExpected) {
-    const result = await testPseudo(
-      query,
-      initial,
-      copyGraphSelectionState(partial),
-    )
-    t.strictSame(
-      result.nodes.map(i => i.name),
-      expected,
-      `query > "${query}"`,
-    )
-    t.matchSnapshot(
-      {
-        edges: result.edges.map(i => i.name).sort(),
-        nodes: result.nodes.map(i => i.name).sort(),
-      },
-      `query > "${query}"`,
-    )
-  }
-
-  await t.test('workspace', async t => {
-    const wsGraph = getSingleWorkspaceGraph()
-    const all: GraphSelectionState = {
-      edges: new Set(wsGraph.edges),
-      nodes: new Set(wsGraph.nodes.values()),
-    }
-    const w: GraphSelectionState = {
-      edges: new Set(),
-      nodes: new Set([
-        wsGraph.nodes.get(joinDepIDTuple(['workspace', 'w']))!,
-      ]),
-    }
-    const empty: GraphSelectionState = {
-      edges: new Set(),
-      nodes: new Set(),
-    }
-    const queryToExpected = new Set<TestCase>([
-      [':root', all, ['ws']], // root
-      [':project /*all*/', all, ['ws', 'w']], // project = root & workspaces
-      [':project /*empty*/', empty, []], // from empty nodes
-      [':project /*w*/', w, ['w']], // from single node
-      [':empty', all, ['ws', 'w']], // deps with no deps
-      [':is(:workspace, :root)', all, ['ws', 'w']],
-      [':is(:workspace, :root)', empty, []],
-      [':is(:workspace)', all, ['w']],
-      [':is(:workspace)', empty, []],
-      [':not(:workspace, :root)', all, []], // excludes all items
-      [':not(:workspace)', all, ['ws']], // excludes workspaces
-      [':not(:root)', all, ['w']], // excludes root
-      [':not(:root)', empty, []], // empty starting partial
-      [':private', all, []], // private dep
-      [':type(registry)', all, []], // type selector
-      [':type(workspace)', all, ['w']], // type selector workspace
-      [':type(file)', all, ['ws']], // type selector root
-      [':dev', all, []], // no dev deps in this graph
-      [':dev', empty, []], // empty starting partial
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-
-    // test custom scopedID
-    const result = await testPseudo(
-      ':scope',
-      initial,
-      copyGraphSelectionState(all),
-      false,
-      [joinDepIDTuple(['workspace', 'w'])],
-    )
-    t.strictSame(
-      result.nodes.map(i => i.name),
-      ['w'],
-      'query > customScopedID',
-    )
-    t.matchSnapshot(
-      {
-        edges: result.edges.map(i => i.name).sort(),
-        nodes: result.nodes.map(i => i.name).sort(),
-      },
-      'query > customScopedID',
-    )
-  })
-
-  await t.test('complex workspace', async t => {
-    const wsGraph = getMultiWorkspaceGraph()
-    const all: GraphSelectionState = {
-      edges: new Set(wsGraph.edges),
-      nodes: new Set(wsGraph.nodes.values()),
-    }
-    //const w = getGraphSelectionState(wsGraph, 'w')
-    const queryToExpected = new Set<TestCase>([
-      [':root', all, ['ws']], // root
-      [':project', all, ['ws', 'a', 'b', 'c']], // project = root & workspaces
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-
-  await t.test('cycle', async t => {
-    const cycleGraph = getCycleGraph()
-    const all: GraphSelectionState = {
-      edges: new Set(cycleGraph.edges),
-      nodes: new Set(cycleGraph.nodes.values()),
-    }
-    const queryToExpected = new Set<TestCase>([
-      [':root', all, ['cycle-project']], // root
-      [':project', all, ['cycle-project']], // project = root & workspaces
-      [':attr([scripts])', all, ['a', 'b']], // any pkgs with scripts
-      [':attr(scripts, [test=foo])', all, ['a']], // any pkgs with scripts
-      [':empty', all, []], // no deps with no deps
-      [':is([name=a])', all, ['a']],
-      [':private', all, []], // private dep
-      [':type(registry)', all, ['a', 'b']], // type selector
-      [':dev', all, []], // no dev deps in this graph
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-
-  await t.test('missing manifest', async t => {
-    const mmGraph = getMissingManifestsGraph()
-    const all: GraphSelectionState = {
-      edges: new Set(mmGraph.edges),
-      nodes: new Set(mmGraph.nodes.values()),
-    }
-    const queryToExpected = new Set<TestCase>([
-      [':attr([scripts])', all, []],
-      [':attr(scripts, [test=foo])', all, []],
-      [':is([name=a])', all, []],
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-
-  await t.test('missing node', async t => {
-    const missingNodeGraph = getMissingNodeGraph()
-    const all: GraphSelectionState = {
-      edges: new Set(missingNodeGraph.edges),
-      nodes: new Set(missingNodeGraph.nodes.values()),
-    }
-    // tests on missing node cases use only snapshot-check
-    // giving that we want to assert missing / present edges
-    const queryToExpected = new Set<TestCase>([
-      [':missing', all, []],
-      [':has(:dev)', all, []],
-      [':private', all, []],
-      [':dev', all, []], // test that :dev works with missing nodes as well
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial] of queryToExpected) {
-      const result = await testPseudo(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-})
-
-t.test('bad selector type', async t => {
-  await t.rejects(
-    testPseudo('[name=a]'),
-    /Mismatching query node/,
-    'should throw an error',
-  )
-})
-
-t.test('unsupported pseudo', async t => {
-  await t.rejects(
-    testPseudo(':unsupportedpseudoclass'),
-    {
-      message: 'Unsupported pseudo-class: :unsupportedpseudoclass',
-      cause: { code: 'EQUERY', found: ':unsupportedpseudoclass' },
-    },
-    'should throw an unsupported selector error',
-  )
-
-  await t.rejects(
-    testPseudo(':difff'),
-    { cause: { wanted: ':diff' } },
-    'should suggest the one pseudo-class a typo away',
-  )
-
-  await t.rejects(
-    testPseudo(':difff(main)'),
-    { cause: { found: ':difff(main)', wanted: ':diff' } },
-    'should suggest past the arguments',
-  )
-
-  await t.rejects(
-    testPseudo(':dif'),
-    { cause: { validOptions: [':diff', ':dev', ':dist', ':is'] } },
-    'should list every pseudo-class a typo away',
-  )
-})
-
-t.test('specificity calculation for pseudo selectors', async t => {
-  const simpleGraph = getSimpleGraph()
-  const all = {
-    edges: new Set(simpleGraph.edges),
-    nodes: new Set(simpleGraph.nodes.values()),
-  }
-  const initial = copyGraphSelectionState(all)
-
-  // Test normal pseudo selectors (should increment commonCounter)
-  const normalState: ParserState = {
-    cancellable: async () => {},
-    collect: {
-      nodes: new Set(simpleGraph.nodes.values()),
-      edges: new Set(simpleGraph.edges),
-    },
-    current: {
-      type: 'pseudo',
-      value: ':dev',
-      spaces: { before: '', after: '' },
-    } as any,
-    initial: copyGraphSelectionState(initial),
-    loose: false,
-    partial: copyGraphSelectionState(initial),
-    importers: new Set(simpleGraph.importers),
-    hostContexts: undefined,
-    retries: 0,
-    securityArchive: undefined,
-    signal: { throwIfAborted: () => {} } as AbortSignal,
-    walk: async (state: ParserState) => state,
-    specificity: { idCounter: 0, commonCounter: 0 },
-    comment: '',
-  }
-
-  const result = await pseudo(normalState)
-  t.equal(
-    result.specificity.commonCounter,
-    1,
-    ':dev should increment commonCounter',
-  )
-
-  // Test :not, :is, :has pseudo selectors (should not increment commonCounter)
-  const notCounter = { idCounter: 0, commonCounter: 0 }
-  const isCounter = { idCounter: 0, commonCounter: 0 }
-  const hasCounter = { idCounter: 0, commonCounter: 0 }
-
-  const notState: ParserState = {
-    ...normalState,
-    current: {
-      type: 'pseudo',
-      value: ':not',
-      spaces: { before: '', after: '' },
-      nodes: [],
-    } as unknown as PostcssNodeWithChildren,
-    specificity: { ...notCounter },
-  }
-
-  const isState: ParserState = {
-    ...normalState,
-    current: {
-      type: 'pseudo',
-      value: ':is',
-      spaces: { before: '', after: '' },
-      nodes: [],
-    } as unknown as PostcssNodeWithChildren,
-    specificity: { ...isCounter },
-  }
-
-  const hasState: ParserState = {
-    ...normalState,
-    current: {
-      type: 'pseudo',
-      value: ':has',
-      spaces: { before: '', after: '' },
-      nodes: [],
-    } as unknown as PostcssNodeWithChildren,
-    specificity: { ...hasCounter },
-  }
-
-  const notResult = await pseudo(notState)
-  const isResult = await pseudo(isState)
-  const hasResult = await pseudo(hasState)
-
-  t.equal(
-    notResult.specificity.commonCounter,
-    0,
-    ':not should not increment commonCounter',
-  )
-  t.equal(
-    isResult.specificity.commonCounter,
-    0,
-    ':is should not increment commonCounter',
-  )
-  t.equal(
-    hasResult.specificity.commonCounter,
-    0,
-    ':has should not increment commonCounter',
-  )
-})
-
-t.test(':path selector', async t => {
-  const pathBasedGraph = getPathBasedGraph()
-  const all = {
-    edges: new Set(pathBasedGraph.edges),
-    nodes: new Set(pathBasedGraph.nodes.values()),
-  }
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-
-  const queryToExpected = new Set<TestCase>([
-    // Test basic path matching - all patterns must be quoted
-    [
-      ':path("*")',
-      all,
-      ['path-based-project', 'a', 'b', 'c', 'x', 'y'],
-    ], // Match all workspace and file nodes
-    [':path("packages/*")', all, ['a', 'b']], // Match workspace packages in packages directory
-    [':path("packages/a")', all, ['a']], // Match specific workspace
-    [':path(".")', all, ['path-based-project']], // Match root project
-    [':path("x")', all, ['x']], // Match file dependency
-    [':path("packages/**")', all, ['a', 'b', 'y']], // Match with glob patterns
-    [':path("packages/a/*")', all, ['y']], // Match nested file paths
-    [':path("nonexistent/**")', all, []], // No matches
-
-    // Test edge cases
-    [':path("")', all, []], // Empty pattern should match nothing
-    [':path()', all, []], // Missing pattern should match nothing
-
-    // Test from empty partial
-    [':path("*")', empty, []], // Empty input should return empty
-  ])
-
-  for (const [query, partial, expectedNames] of queryToExpected) {
-    try {
-      // Convert string names to DepID array
-      const expectedDepIDs = expectedNames.map(name =>
-        joinDepIDTuple(['registry', '', `${name}@1.0.0`]),
-      )
-      await testPseudo(query, all, partial, false, expectedDepIDs)
-    } catch (error) {
-      t.fail(`Failed query "${query}": ${error}`)
-    }
-  }
-})
-
-t.test('unexpected attr usage', async t => {
-  await t.rejects(
-    testPseudo(':attr', undefined, undefined, true),
-    /Failed to parse :attr selector/,
-    'should throw a failure to parse error',
-  )
-})
-
-t.test('pseudo-class names match dss-parser grammar', async t => {
-  t.strictSame(pseudoSelectorNames, new Set(pseudoClassNames))
-})

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json"
-}

package/tsconfig.publish.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.mts",
-    "src/**/*.tsx",
-    "src/**/*.json"
-  ],
-  "exclude": ["src/package.json"],
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "sourceMap": false,
-    "declarationMap": false,
-    "inlineSources": false
-  }
-}