@vltpkg/query 1.5.0 → 1.6.1

package/src/pseudo.ts

@@ -1,440 +0,0 @@
-import { error } from '@vltpkg/error-cause'
-import { removeDanglingEdges, removeNode } from './pseudo/helpers.ts'
-import { didYouMean, queryError, selectorText } from './error.ts'
-import {
-  asPostcssNodeWithChildren,
-  asPseudoNode,
-  isSelectorNode,
-} from '@vltpkg/dss-parser'
-
-// imported pseudo selectors
-import { abandoned } from './pseudo/abandoned.ts'
-import { attr } from './pseudo/attr.ts'
-import { built } from './pseudo/built.ts'
-import { confused } from './pseudo/confused.ts'
-import { cve } from './pseudo/cve.ts'
-import { cwe } from './pseudo/cwe.ts'
-import { debug } from './pseudo/debug.ts'
-import { deprecated } from './pseudo/deprecated.ts'
-import { dev } from './pseudo/dev.ts'
-import { diff } from './pseudo/diff.ts'
-import { dist } from './pseudo/dist.ts'
-import { dynamic } from './pseudo/dynamic.ts'
-import { empty } from './pseudo/empty.ts'
-import { entropic } from './pseudo/entropic.ts'
-import { env } from './pseudo/env.ts'
-import { evalParser } from './pseudo/eval.ts'
-import { fs } from './pseudo/fs.ts'
-import { hostContext } from './pseudo/host.ts'
-import { hostname } from './pseudo/hostname.ts'
-import { license } from './pseudo/license.ts'
-import { link } from './pseudo/link.ts'
-import { malware } from './pseudo/malware.ts'
-import { minified } from './pseudo/minified.ts'
-import { missing } from './pseudo/missing.ts'
-import { nativeParser } from './pseudo/native.ts'
-import { network } from './pseudo/network.ts'
-import { obfuscated } from './pseudo/obfuscated.ts'
-import { optional } from './pseudo/optional.ts'
-import { outdated } from './pseudo/outdated.ts'
-import { overridden } from './pseudo/overridden.ts'
-import { path } from './pseudo/path.ts'
-import { peer } from './pseudo/peer.ts'
-import { prerelease } from './pseudo/prerelease.ts'
-import { published } from './pseudo/published.ts'
-import { privateParser } from './pseudo/private.ts'
-import { registry } from './pseudo/registry.ts'
-import { prod } from './pseudo/prod.ts'
-import { root } from './pseudo/root.ts'
-import { scanned } from './pseudo/scanned.ts'
-import { score } from './pseudo/score.ts'
-import { scripts } from './pseudo/scripts.ts'
-import { shell } from './pseudo/shell.ts'
-import { semverParser as semver } from './pseudo/semver.ts'
-import { severity } from './pseudo/severity.ts'
-import { spec } from './pseudo/spec.ts'
-import { shrinkwrap } from './pseudo/shrinkwrap.ts'
-import { skill } from './pseudo/skill.ts'
-import { skills } from './pseudo/skills.ts'
-import { squat } from './pseudo/squat.ts'
-import { suspicious } from './pseudo/suspicious.ts'
-import { tracker } from './pseudo/tracker.ts'
-import { trivial } from './pseudo/trivial.ts'
-import { type } from './pseudo/type.ts'
-import { undesirable } from './pseudo/undesirable.ts'
-import { unknown } from './pseudo/unknown.ts'
-import { unmaintained } from './pseudo/unmaintained.ts'
-import { unpopular } from './pseudo/unpopular.ts'
-import { unstable } from './pseudo/unstable.ts'
-import { vuln } from './pseudo/vuln.ts'
-import { workspace } from './pseudo/workspace.ts'
-
-import type { PseudoClassName } from '@vltpkg/dss-parser'
-import type { EdgeLike, NodeLike } from '@vltpkg/types'
-import type { ParserFn, ParserState } from './types.ts'
-
-/**
- * :has Pseudo-Selector, matches only nodes that have valid results
- * for its nested selector expressions.
- */
-const has = async (state: ParserState) => {
-  const top = asPostcssNodeWithChildren(state.current)
-  const collectNodes = new Set<NodeLike>()
-  const collectEdges = new Set<EdgeLike>()
-
-  for (const node of top.nodes) {
-    if (isSelectorNode(node)) {
-      const nestedState = await state.walk({
-        cancellable: state.cancellable,
-        initial: {
-          edges: new Set(state.initial.edges),
-          nodes: new Set(state.initial.nodes),
-        },
-        current: node,
-        walk: state.walk,
-        collect: {
-          edges: new Set(),
-          nodes: new Set(),
-        },
-        partial: {
-          edges: new Set(state.partial.edges),
-          nodes: new Set(state.partial.nodes),
-        },
-        diffFiles: state.diffFiles,
-        hasSkills: state.hasSkills,
-        loose: state.loose,
-        hostContexts: state.hostContexts,
-        importers: state.importers,
-        retries: state.retries,
-        securityArchive: state.securityArchive,
-        signal: state.signal,
-        scopeIDs: state.scopeIDs,
-        comment: state.comment,
-        specificity: { ...state.specificity },
-      })
-      for (const n of nestedState.collect.nodes) {
-        collectNodes.add(n)
-      }
-      for (const e of nestedState.partial.edges) {
-        collectEdges.add(e)
-      }
-    }
-  }
-
-  // if the nested selector did not match anything, that means
-  // no current node has any matches
-  if (collectNodes.size === 0) {
-    state.partial.edges.clear()
-    state.partial.nodes.clear()
-    return state
-  }
-
-  // handles transitive dependencies
-  // compareNodes collects a list of all ancestor nodes
-  // from the resulting nodes of the nested selector
-  const compareNodes = new Set<NodeLike>()
-  const traverse = new Set(collectNodes)
-  for (const node of traverse) {
-    for (const edge of node.edgesIn) {
-      compareNodes.add(edge.from)
-      if (edge.from.edgesIn.size) {
-        traverse.add(edge.from)
-      }
-    }
-  }
-
-  // for each node in the current list checks to see if
-  // it has a node in the resulting nested state that is
-  // a transitive dependency / children.
-  nodesLoop: for (const node of state.partial.nodes) {
-    if (node.edgesOut.size === 0 || !compareNodes.has(node)) {
-      removeNode(state, node)
-      continue
-    }
-
-    for (const edge of node.edgesOut.values()) {
-      if (collectEdges.has(edge)) {
-        continue nodesLoop
-      }
-    }
-    removeNode(state, node)
-  }
-
-  removeDanglingEdges(state)
-
-  return state
-}
-
-/**
- * :is Pseudo-selector, acts as a shortcut for writing more compact expressions
- * by allowing multiple nested selectors to match on the previous results.
- *
- * It also enables the loose parsing mode, skipping instead of erroring usage
- * of non-existing classes, identifiers, pseudo-classes, etc.
- */
-const is = async (state: ParserState) => {
-  const top = asPostcssNodeWithChildren(state.current)
-  const collect = new Set()
-  for (const node of top.nodes) {
-    if (isSelectorNode(node)) {
-      const nestedState = await state.walk({
-        cancellable: state.cancellable,
-        collect: {
-          edges: new Set(),
-          nodes: new Set(),
-        },
-        current: node,
-        diffFiles: state.diffFiles,
-        hasSkills: state.hasSkills,
-        initial: state.initial,
-        loose: true,
-        partial: {
-          nodes: new Set(state.partial.nodes),
-          edges: new Set(state.partial.edges),
-        },
-        importers: state.importers,
-        hostContexts: state.hostContexts,
-        walk: state.walk,
-        retries: state.retries,
-        securityArchive: state.securityArchive,
-        signal: state.signal,
-        scopeIDs: state.scopeIDs,
-        comment: state.comment,
-        specificity: { ...state.specificity },
-      })
-      for (const n of nestedState.collect.nodes) {
-        collect.add(n)
-      }
-    }
-  }
-  for (const node of state.partial.nodes) {
-    if (!collect.has(node)) {
-      removeNode(state, node)
-    }
-  }
-  return state
-}
-
-/**
- * :not Pseudo-class, serves to create negate expressions, anything that
- * matches selectors declared inside the `:not()` expression is going to be
- * filtered out in the final result.
- */
-const not = async (state: ParserState) => {
-  const top = asPostcssNodeWithChildren(state.current)
-  const collect = new Set()
-  for (const node of top.nodes) {
-    if (isSelectorNode(node)) {
-      const nestedState = await state.walk({
-        cancellable: state.cancellable,
-        collect: {
-          edges: new Set(),
-          nodes: new Set(),
-        },
-        current: node,
-        diffFiles: state.diffFiles,
-        hasSkills: state.hasSkills,
-        initial: state.initial,
-        loose: state.loose,
-        partial: {
-          nodes: new Set(state.partial.nodes),
-          edges: new Set(state.partial.edges),
-        },
-        importers: state.importers,
-        hostContexts: state.hostContexts,
-        walk: state.walk,
-        retries: state.retries,
-        securityArchive: state.securityArchive,
-        signal: state.signal,
-        scopeIDs: state.scopeIDs,
-        comment: state.comment,
-        specificity: { ...state.specificity },
-      })
-      for (const n of nestedState.collect.nodes) {
-        collect.add(n)
-      }
-      /* c8 ignore start - should be impossible */
-    } else {
-      throw error('Error parsing :not() selectors', {
-        wanted: { type: 'selector' },
-        found: node,
-      })
-    }
-    /* c8 ignore stop */
-  }
-  for (const node of state.partial.nodes) {
-    if (collect.has(node)) {
-      removeNode(state, node)
-    }
-  }
-
-  removeDanglingEdges(state)
-
-  return state
-}
-
-/**
- * :project Pseudo-Class, matches only graph importers (e.g: the
- * root node along with any configured workspace)
- */
-const project = async (state: ParserState) => {
-  for (const node of state.partial.nodes) {
-    if (!node.importer) {
-      removeNode(state, node)
-    }
-  }
-  for (const edge of state.partial.edges) {
-    if (!edge.to?.importer) {
-      state.partial.edges.delete(edge)
-    }
-  }
-  return state
-}
-
-/**
- * :scope Pseudo-Element, returns only the nodes that match the provided scopeIDs
- * from the Query.search method.
- */
-const scope = async (state: ParserState) => {
-  const scopeIDSet = new Set(state.scopeIDs)
-
-  for (const node of state.partial.nodes) {
-    if (!scopeIDSet.has(node.id)) {
-      removeNode(state, node)
-    }
-  }
-
-  removeDanglingEdges(state)
-
-  return state
-}
-
-const pseudoSelectors = new Map<string, ParserFn>(
-  Object.entries({
-    abandoned,
-    attr,
-    built,
-    confused,
-    cve,
-    cwe,
-    debug,
-    deprecated,
-    dev,
-    diff,
-    dist,
-    dynamic,
-    eval: evalParser,
-    empty,
-    entropic,
-    env,
-    fs,
-    has,
-    host: hostContext,
-    hostname,
-    is,
-    license,
-    link,
-    malware,
-    minified,
-    missing,
-    native: nativeParser,
-    network,
-    not,
-    obfuscated,
-    optional,
-    outdated,
-    overridden,
-    path,
-    peer,
-    prerelease,
-    published,
-    private: privateParser,
-    prod,
-    registry,
-    project,
-    root,
-    scanned,
-    scope,
-    score,
-    scripts,
-    semver,
-    sev: severity,
-    spec,
-    severity,
-    shell,
-    shrinkwrap,
-    skill,
-    skills,
-    squat,
-    suspicious,
-    tracker,
-    trivial,
-    type,
-    undesirable,
-    unknown,
-    unmaintained,
-    unpopular,
-    unstable,
-    v: semver,
-    vuln,
-    vulnerable: vuln,
-    workspace,
-  } satisfies Record<PseudoClassName, ParserFn>),
-)
-
-/**
- * Names of every supported pseudo-class, without the leading `:`.
- */
-export const pseudoSelectorNames: ReadonlySet<string> = new Set(
-  pseudoSelectors.keys(),
-)
-
-/**
- * Parsers the `pseudo` node types.
- */
-export const pseudo = async (state: ParserState) => {
-  await state.cancellable()
-
-  const curr = asPseudoNode(state.current)
-  const parserFn =
-    curr.value && pseudoSelectors.get(curr.value.slice(1))
-
-  if (!parserFn) {
-    if (state.loose) {
-      state.partial.edges.clear()
-      state.partial.nodes.clear()
-      return state
-    }
-
-    // `:difff(x)` should still suggest `:diff`, so drop any arguments
-    const name = selectorText(state.current)
-      .replace(/^:/, '')
-      .replace(/\(.*$/s, '')
-    const suggestions = didYouMean(name, pseudoSelectorNames).map(
-      n => `:${n}`,
-    )
-    throw queryError(
-      `Unsupported pseudo-class: ${state.current.value}`,
-      state.current,
-      suggestions.length > 1 ?
-        { validOptions: suggestions }
-      : { wanted: suggestions[0] },
-    )
-  }
-
-  const result = await parserFn(state)
-
-  // Increment the commonCounter for specificity, except for
-  // nesting selectors which don't contribute to specificity
-  const pseudoValue = curr.value.slice(1)
-  if (
-    pseudoValue &&
-    pseudoValue !== 'not' &&
-    pseudoValue !== 'is' &&
-    pseudoValue !== 'has'
-  ) {
-    result.specificity.commonCounter += 1
-  }
-
-  return result
-}

package/src/types.ts

@@ -1,206 +0,0 @@
-import type { EdgeLike, NodeLike } from '@vltpkg/types'
-import type {
-  SecurityArchiveLike,
-  PackageScore,
-} from '@vltpkg/security-archive'
-import type { DepID } from '@vltpkg/dep-id'
-import type { PartPseudoName, PostcssNode } from '@vltpkg/dss-parser'
-
-export type HostContextsMapResult = {
-  initialEdges: EdgeLike[]
-  initialNodes: NodeLike[]
-  edges: EdgeLike[]
-  nodes: NodeLike[]
-  securityArchive: SecurityArchiveLike | undefined
-}
-
-export type HostContextsMap = Map<
-  string,
-  () => Promise<HostContextsMapResult>
->
-
-export type Specificity = {
-  idCounter: number
-  commonCounter: number
-}
-
-export type GraphSelectionState = {
-  nodes: Set<NodeLike>
-  edges: Set<EdgeLike>
-}
-
-/**
- * Callback that returns changed file paths for a given
- * commitish reference. Used by the :diff() pseudo selector.
- * The returned paths should be relative to the project root.
- */
-export type DiffFilesProvider = (commitish: string) => Set<string>
-
-/**
- * Callback that returns the `authorization` header value to use when
- * fetching data from a registry URL, e.g. by the :outdated() pseudo
- * selector. Keeps the browser-safe query package free of any direct
- * keychain / registry-client dependency.
- */
-export type GetAuthHeader = (
-  url: string,
-) => Promise<string | undefined>
-
-/**
- * Whether an installed package ships agent skills; for `:skills`.
- * Keeps fs out of this package.
- */
-export type HasSkills = (node: NodeLike) => Promise<boolean>
-
-/**
- * One top-level selector of a query and the nodes it matched. `name`
- * and `patterns` are set when it ends in a part selector, e.g.
- * `#a:skill(x, y*)`.
- */
-export type QueryPart<N = QueryResponseNode> = {
-  name?: PartPseudoName
-  /** as typed, `*` = glob; for matching only, never paths */
-  patterns?: string[]
-  nodes: N[]
-}
-
-export type ParserState = {
-  cancellable: () => Promise<void>
-  collect: GraphSelectionState
-  comment: string
-  current: PostcssNode
-  diffFiles?: DiffFilesProvider
-  getAuthHeader?: GetAuthHeader
-  hasSkills?: HasSkills
-  hostContexts?: HostContextsMap
-  importers: Set<NodeLike>
-  initial: GraphSelectionState
-  loose?: boolean
-  next?: PostcssNode
-  prev?: PostcssNode
-  result?: NodeLike[]
-  signal: AbortSignal
-  walk: ParserFn
-  partial: GraphSelectionState
-  /** set by `:skill()`, read and cleared by `walk()` */
-  part?: Pick<QueryPart, 'name' | 'patterns'>
-  /** one entry per top-level selector, only when opted in */
-  parts?: QueryPart<NodeLike>[]
-  /** part selectors this consumer allows */
-  partSelectors?: ReadonlySet<PartPseudoName>
-  retries: number
-  securityArchive: SecurityArchiveLike | undefined
-  scopeIDs?: DepID[]
-  specificity: Specificity
-}
-
-export type QueryResponse = {
-  edges: QueryResponseEdge[]
-  nodes: QueryResponseNode[]
-  importers: QueryResponseNode[]
-  comment: string
-  specificity: Specificity
-  /**
-   * one entry per top-level selector, only with `partSelectors` and
-   * a non-empty query
-   */
-  parts?: QueryPart[]
-}
-
-export type QueryResponseEdge = Omit<EdgeLike, 'from' | 'to'> & {
-  from: QueryResponseNode
-  to?: QueryResponseNode
-}
-
-export type QueryResponseNode = Omit<
-  NodeLike,
-  'edgesIn' | 'edgesOut'
-> & {
-  edgesIn: Set<QueryResponseEdge>
-  edgesOut: Map<string, QueryResponseEdge>
-  insights: Insights
-  toJSON: () => Pick<
-    QueryResponseNode,
-    | 'id'
-    | 'name'
-    | 'version'
-    | 'location'
-    | 'importer'
-    | 'manifest'
-    | 'projectRoot'
-    | 'integrity'
-    | 'resolved'
-    | 'dev'
-    | 'optional'
-    | 'insights'
-    | 'confused'
-  >
-}
-
-export type Insights = {
-  abandoned?: boolean
-  confused?: boolean
-  cve?: `CVE-${string}`[]
-  cwe?: `CWE-${string}`[]
-  debug?: boolean
-  deprecated?: boolean
-  dynamic?: boolean
-  entropic?: boolean
-  env?: boolean
-  eval?: boolean
-  fs?: boolean
-  license?: LicenseInsights
-  malware?: boolean
-  minified?: boolean
-  native?: boolean
-  network?: boolean
-  obfuscated?: boolean
-  scanned: boolean
-  score?: PackageScore
-  scripts?: boolean
-  severity?: SeverityInsights
-  shell?: boolean
-  shrinkwrap?: boolean
-  squat?: SquatInsights
-  suspicious?: boolean
-  tracker?: boolean
-  trivial?: boolean
-  undesirable?: boolean
-  unknown?: boolean
-  unmaintained?: boolean
-  unpopular?: boolean
-  unstable?: boolean
-  vuln?: VulnInsights
-}
-
-export type LicenseInsights = {
-  unlicensed: boolean
-  misc: boolean
-  restricted: boolean
-  ambiguous: boolean
-  copyleft: boolean
-  unknown: boolean
-  none: boolean
-  exception: boolean
-}
-
-export type LeveledInsights = {
-  low: boolean
-  medium: boolean
-  high: boolean
-  critical: boolean
-}
-
-export type SeverityInsights = LeveledInsights
-export type VulnInsights = LeveledInsights
-
-export type SquatInsights = {
-  medium: boolean
-  critical: boolean
-}
-
-export type ParserFn = (opt: ParserState) => Promise<ParserState>
-
-export type ParsedSelectorToken = PostcssNode & {
-  token: string
-}