@vltpkg/query 1.4.0 → 1.6.0

package/test/pseudo/peer.ts

@@ -1,101 +0,0 @@
-import t from 'tap'
-import { pseudo } from '../../src/pseudo.ts'
-import {
-  selectorFixture,
-  copyGraphSelectionState,
-} from '../fixtures/selector.ts'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-import type { TestCase } from '../fixtures/types.ts'
-import type { GraphSelectionState } from '../../src/types.ts'
-
-const testPseudo = selectorFixture(pseudo)
-
-t.test(':peer pseudo-selector', async t => {
-  // Get a simple graph for testing
-  const simpleGraph = getSimpleGraph()
-
-  // Create a peer dependency edge for testing
-  // Find an existing edge and change its type to 'peer'
-  for (const edge of simpleGraph.edges) {
-    if (edge.name === 'c') {
-      edge.type = 'peer'
-      break
-    }
-  }
-
-  // Get the full selection state
-  const all = {
-    edges: new Set(simpleGraph.edges),
-    nodes: new Set(simpleGraph.nodes.values()),
-  }
-
-  // Create an empty selection state
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-
-  // Run tests in the same pattern as the main pseudo.ts tests
-  const queryToExpected = new Set<TestCase>([
-    [':peer', all, ['c']], // Should return nodes with peer dependency edges
-    [':peer', empty, []], // Empty input should return empty output
-  ])
-
-  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}"`,
-    )
-
-    // Verify all edges are peer dependencies
-    const edgeArray = [...result.edges]
-    if (edgeArray.length > 0) {
-      for (const edge of edgeArray) {
-        t.ok(
-          edge.type === 'peer' || edge.type === 'peerOptional',
-          `edge ${edge.name} should have type 'peer' or 'peerOptional'`,
-        )
-      }
-    }
-  }
-
-  // Test peerOptional type
-  t.test('handles peerOptional dependencies', async t => {
-    // Change an edge to peerOptional for testing
-    for (const edge of simpleGraph.edges) {
-      if (edge.name === 'd') {
-        edge.type = 'peerOptional'
-        break
-      }
-    }
-
-    // Run the test
-    const result = await testPseudo(
-      ':peer',
-      initial,
-      copyGraphSelectionState(all),
-    )
-
-    // Result should include both peer and peerOptional dependencies
-    const nodeArray = [...result.nodes]
-    t.ok(
-      nodeArray.length >= 2,
-      'Result should include both peer and peerOptional dependencies',
-    )
-
-    // Verify that our peerOptional dependency is included
-    const nodeNames = nodeArray.map(n => n.name)
-    t.ok(
-      nodeNames.includes('d'),
-      'Result should include the peerOptional dependency',
-    )
-  })
-})

package/test/pseudo/prerelease.ts

@@ -1,279 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import type { ParserState } from '../../src/types.ts'
-import { prerelease } from '../../src/pseudo/prerelease.ts'
-import { parse } from '@vltpkg/semver'
-import {
-  getSemverRichGraph,
-  getSimpleGraph,
-  newGraph,
-  newNode,
-} from '../fixtures/graph.ts'
-
-t.test(':prerelease pseudo-selector', async t => {
-  const getState = (query: string, graph = getSemverRichGraph()) => {
-    const ast = postcssSelectorParser().astSync(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      partial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      retries: 0,
-      securityArchive: undefined,
-      importers: new Set(graph.importers),
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test(
-    'selects only nodes with prerelease versions',
-    async t => {
-      const res = await prerelease(getState(':prerelease'))
-
-      // Should only select nodes with prerelease versions
-      const nodeNames = [...res.partial.nodes].map(n => n.name).sort()
-      const nodeVersions = [...res.partial.nodes]
-        .map(n => n.version)
-        .sort()
-
-      t.strictSame(
-        nodeNames,
-        ['e', 'g'],
-        'should select only nodes with prerelease versions',
-      )
-
-      t.strictSame(
-        nodeVersions,
-        ['1.2.3-rc.1+rev.2', '1.3.4-beta.1'],
-        'should select correct prerelease versions',
-      )
-
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => ({
-          name: n.name,
-          version: n.version,
-        })),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test('excludes non-prerelease versions', async t => {
-    const res = await prerelease(getState(':prerelease'))
-
-    // Verify that only prerelease versions remain
-    for (const node of res.partial.nodes) {
-      const version = node.manifest?.version
-      if (version) {
-        const parsed = parse(version)
-        t.ok(
-          parsed?.prerelease?.length,
-          `${node.name}@${version} should have prerelease identifiers`,
-        )
-      }
-    }
-
-    t.matchSnapshot([...res.partial.nodes].map(n => n.version).sort())
-  })
-
-  await t.test('handles nodes without version', async t => {
-    const graph = newGraph('test-project')
-    const addNode = newNode(graph)
-
-    // Create a node without version
-    const nodeWithoutVersion = addNode('no-version', '1.0.0')
-    nodeWithoutVersion.manifest = { name: 'no-version' } // No version field
-    graph.nodes.set(nodeWithoutVersion.id, nodeWithoutVersion)
-
-    const res = await prerelease(getState(':prerelease', graph))
-
-    t.strictSame(
-      [...res.partial.nodes].length,
-      0,
-      'should exclude all nodes when none have prerelease versions',
-    )
-
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => ({
-        name: n.name,
-        version: n.version,
-      })),
-    })
-  })
-
-  await t.test('handles nodes with invalid semver', async t => {
-    const graph = newGraph('test-project')
-    const addNode = newNode(graph)
-
-    // Create a node with invalid semver
-    const nodeWithInvalidSemver = addNode('invalid-semver', '1.0.0')
-    nodeWithInvalidSemver.version = 'not-a-semver'
-    nodeWithInvalidSemver.manifest = {
-      name: 'invalid-semver',
-      version: 'not-a-semver',
-    }
-    graph.nodes.set(nodeWithInvalidSemver.id, nodeWithInvalidSemver)
-
-    const res = await prerelease(getState(':prerelease', graph))
-
-    t.strictSame(
-      [...res.partial.nodes].length,
-      0,
-      'should exclude all nodes when none have valid prerelease versions',
-    )
-
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => ({
-        name: n.name,
-        version: n.version,
-      })),
-    })
-  })
-
-  await t.test('handles various prerelease formats', async t => {
-    const graph = newGraph('prerelease-test')
-    const addNode = newNode(graph)
-
-    // Create nodes with various prerelease formats
-    const testCases = [
-      { name: 'canary', version: '19.2.0-canary-fa3feba6-20250623' },
-      { name: 'beta', version: '1.0.0-beta.0' },
-      { name: 'alpha', version: '2.1.0-alpha.1' },
-      { name: 'rc', version: '3.0.0-rc.2' },
-      { name: 'dev', version: '0.0.0-16' },
-      { name: 'next', version: '1.5.0-next.1' },
-      { name: 'snapshot', version: '2.0.0-snapshot.20231201' },
-      { name: 'build-meta', version: '1.2.3-alpha.1+build.123' },
-      { name: 'stable', version: '1.0.0' }, // This should be filtered out
-      { name: 'another-stable', version: '2.5.3' }, // This should be filtered out
-    ]
-
-    for (const testCase of testCases) {
-      const node = addNode(testCase.name, testCase.version)
-      node.version = testCase.version
-      node.manifest = {
-        name: testCase.name,
-        version: testCase.version,
-      }
-      graph.nodes.set(node.id, node)
-    }
-
-    const res = await prerelease(getState(':prerelease', graph))
-
-    const selectedNodes = [...res.partial.nodes]
-      .map(n => ({ name: n.name, version: n.version }))
-      .sort((a, b) => (a.name || '').localeCompare(b.name || ''))
-
-    // Should select all prerelease versions but exclude stable ones
-    const expectedNodes = testCases
-      .filter(tc => tc.version.includes('-'))
-      .map(tc => ({ name: tc.name, version: tc.version }))
-      .sort((a, b) => a.name.localeCompare(b.name))
-
-    t.strictSame(
-      selectedNodes,
-      expectedNodes,
-      'should select all prerelease versions and exclude stable ones',
-    )
-
-    t.matchSnapshot({
-      selected: selectedNodes,
-      total: testCases.length,
-    })
-  })
-
-  await t.test('removes dangling edges properly', async t => {
-    const graph = getSemverRichGraph()
-    const initialEdgeCount = graph.edges.size
-
-    const res = await prerelease(getState(':prerelease', graph))
-
-    // Check that dangling edges were removed
-    const remainingEdges = [...res.partial.edges]
-
-    t.ok(
-      remainingEdges.length <= initialEdgeCount,
-      'should have same or fewer edges after filtering',
-    )
-
-    // Verify all remaining edges connect to nodes that remain
-    for (const edge of remainingEdges) {
-      if (edge.to) {
-        t.ok(
-          res.partial.nodes.has(edge.to),
-          `edge ${edge.name} should have valid to node`,
-        )
-      }
-    }
-
-    t.matchSnapshot({
-      remainingEdges: remainingEdges.length,
-      initialEdges: initialEdgeCount,
-      edgeNames: remainingEdges.map(e => e.name).sort(),
-    })
-  })
-
-  await t.test('works with empty graph', async t => {
-    const emptyGraph = newGraph('empty-test')
-    // Remove all nodes except root
-    emptyGraph.nodes.clear()
-    emptyGraph.edges.clear()
-    emptyGraph.nodes.set(
-      emptyGraph.mainImporter.id,
-      emptyGraph.mainImporter,
-    )
-
-    const res = await prerelease(getState(':prerelease', emptyGraph))
-
-    t.strictSame(
-      [...res.partial.nodes].length,
-      0,
-      'should have no nodes when root has no prerelease version',
-    )
-
-    t.strictSame(
-      [...res.partial.edges].length,
-      0,
-      'should have no edges',
-    )
-  })
-
-  await t.test(
-    'works with simple graph (no prereleases)',
-    async t => {
-      const simpleGraph = getSimpleGraph()
-      const res = await prerelease(
-        getState(':prerelease', simpleGraph),
-      )
-
-      // Simple graph has no prerelease versions
-      t.strictSame(
-        [...res.partial.nodes].length,
-        0,
-        'should have no nodes when no prereleases exist',
-      )
-
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => ({
-          name: n.name,
-          version: n.version,
-        })),
-      })
-    },
-  )
-})

package/test/pseudo/private.ts

@@ -1,108 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import type { ParserState } from '../../src/types.ts'
-import { privateParser } from '../../src/pseudo/private.ts'
-import {
-  getSimpleGraph,
-  getSingleWorkspaceGraph,
-  getCycleGraph,
-} from '../fixtures/graph.ts'
-
-t.test('selects packages with private flag', async t => {
-  const getState = (query: string, graph = getSimpleGraph()) => {
-    const ast = postcssSelectorParser().astSync(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      partial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      retries: 0,
-      securityArchive: undefined,
-      importers: new Set(graph.importers),
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test(
-    'selects nodes with private flag in simple graph',
-    async t => {
-      // Based on the getSimpleGraph fixture, only the 'd' package has private: true
-      const res = await privateParser(getState(':private'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['d'],
-        'should select only packages with private flag set to true',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects no nodes with private flag in workspace graph',
-    async t => {
-      // In getSingleWorkspaceGraph, no nodes have private flag
-      const wsGraph = getSingleWorkspaceGraph()
-      const res = await privateParser(getState(':private', wsGraph))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        [],
-        'should not select any nodes in workspace graph as none have private flag',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test('selects no nodes in cycle graph', async t => {
-    // In getCycleGraph, no nodes have private flag
-    const cycleGraph = getCycleGraph()
-    const res = await privateParser(getState(':private', cycleGraph))
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      [],
-      'should not select any packages in a cycle graph as none have private flag',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-
-  await t.test('handles an empty partial state', async t => {
-    // Create a state with empty partial nodes
-    const state = getState(':private')
-    state.partial.nodes.clear()
-    state.partial.edges.clear()
-
-    const res = await privateParser(state)
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      [],
-      'should return empty array when starting with empty partial state',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-})

package/test/pseudo/prod.ts

@@ -1,61 +0,0 @@
-import t from 'tap'
-import { pseudo } from '../../src/pseudo.ts'
-import {
-  selectorFixture,
-  copyGraphSelectionState,
-} from '../fixtures/selector.ts'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-import type { TestCase } from '../fixtures/types.ts'
-import type { GraphSelectionState } from '../../src/types.ts'
-
-const testPseudo = selectorFixture(pseudo)
-
-t.test(':prod pseudo-selector', async t => {
-  // Get a simple graph for testing
-  const simpleGraph = getSimpleGraph()
-
-  // Get the full selection state
-  const all = {
-    edges: new Set(simpleGraph.edges),
-    nodes: new Set(simpleGraph.nodes.values()),
-  }
-
-  // Create an empty selection state
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-
-  // Run tests in the same pattern as the main pseudo.ts tests
-  const queryToExpected = new Set<TestCase>([
-    [':prod', all, ['a', 'c', 'd', 'e']], // Should return nodes with prod edges
-    [':prod', empty, []], // Empty input should return empty output
-  ])
-
-  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}"`,
-    )
-
-    // Verify all edges are of type 'prod'
-    const edgeArray = [...result.edges]
-    if (edgeArray.length > 0) {
-      for (const edge of edgeArray) {
-        t.equal(
-          edge.type,
-          'prod',
-          `edge ${edge.name} should be of type 'prod'`,
-        )
-      }
-    }
-  }
-})