@vltpkg/query 1.5.0 → 1.6.0

package/src/combinator.ts

@@ -1,135 +0,0 @@
-import { asCombinatorNode } from '@vltpkg/dss-parser'
-import { queryError } from './error.ts'
-import type { CombinatorName } from '@vltpkg/dss-parser'
-import type { EdgeLike, NodeLike } from '@vltpkg/types'
-import type { ParserState, ParserFn } from './types.ts'
-
-/**
- * Returns a new set of nodes, containing all direct dependencies
- * of the current list of nodes used.
- *
- * ref: https://developer.mozilla.org/en-US/docs/Web/CSS/Child_combinator
- */
-const childCombinator = async (state: ParserState) => {
-  const traverse = new Set(state.partial.nodes)
-  state.partial.edges.clear()
-  state.partial.nodes.clear()
-
-  // visit direct children of the current list of nodes
-  // collecting refs to these children and the edges that
-  // connected them.
-  for (const node of traverse) {
-    for (const edge of node.edgesOut.values()) {
-      if (edge.to) {
-        state.partial.edges.add(edge)
-        state.partial.nodes.add(edge.to)
-      }
-    }
-  }
-
-  return state
-}
-
-/**
- * Returns a new set of nodes, containing nodes that are also children
- * of all parent nodes to the current list of nodes used.
- *
- * Note: The subsequent-sibling comparator has a behavior that is
- * somehow approximative of that of its css counterpart, given that
- * in the context of dependency graphs the order of appearance is
- * not necessarily controlled by the end user. The approach for
- * this comparator is to match all siblings of a node.
- *
- * ref: https://developer.mozilla.org/en-US/docs/Web/CSS/Subsequent-sibling_combinator
- */
-const subsequentSiblingCombinator = async (state: ParserState) => {
-  const traverse = new Set(state.partial.nodes)
-  state.partial.edges.clear()
-  state.partial.nodes.clear()
-
-  // visits direct parents of the current list of node and then
-  // visit their children, collecting refs to all children and edges
-  // that are not in the original list of nodes.
-  for (const node of traverse) {
-    for (const edge of node.edgesIn) {
-      const parents: IterableIterator<EdgeLike> =
-        edge.from.edgesOut.values()
-      for (const edge of parents) {
-        if (edge.to && edge.to !== node) {
-          state.partial.edges.add(edge)
-          state.partial.nodes.add(edge.to)
-        }
-      }
-    }
-  }
-
-  return state
-}
-
-/**
- * Returns a new set of nodes containing all nodes that are descendents
- * to items in the current list of nodes.
- *
- * ref: https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_combinator
- */
-const descendentCombinator = async (state: ParserState) => {
-  // spaces between tags selectors are a noop
-  if (state.prev?.type === 'tag' || state.next?.type === 'tag') {
-    return state
-  }
-
-  const traverse = new Set<NodeLike>(state.partial.nodes)
-  state.partial.edges.clear()
-  state.partial.nodes.clear()
-
-  // breadth-first traversal of the graph, starting from the current
-  // list of nodes, collecting all nodes and edges along the way
-  for (const node of traverse) {
-    const children = new Set<NodeLike>()
-    for (const edge of node.edgesOut.values()) {
-      if (edge.to) {
-        children.add(edge.to)
-        state.partial.edges.add(edge)
-        state.partial.nodes.add(edge.to)
-      }
-    }
-    for (const child of children) {
-      traverse.add(child)
-    }
-  }
-
-  return state
-}
-
-const combinatorSelectors = {
-  '>': childCombinator,
-  '~': subsequentSiblingCombinator,
-  ' ': descendentCombinator,
-} satisfies Record<CombinatorName, ParserFn>
-
-const combinatorSelectorsMap = new Map<string, ParserFn>(
-  Object.entries(combinatorSelectors),
-)
-
-/**
- * Parse css-style combinators, e.g: `>`, `~` and ` `
- */
-export const combinator = async (state: ParserState) => {
-  await state.cancellable()
-
-  const curr = asCombinatorNode(state.current)
-  const parserFn =
-    curr.value && combinatorSelectorsMap.get(curr.value)
-  if (!parserFn) {
-    if (state.loose) {
-      return state
-    }
-
-    throw queryError(
-      `Unsupported combinator: ${state.current.value}`,
-      state.current,
-      { validOptions: [...combinatorSelectorsMap.keys()] },
-    )
-  }
-  return parserFn(state)
-}

package/src/error.ts

@@ -1,78 +0,0 @@
-import { error } from '@vltpkg/error-cause'
-import type { ErrorCauseOptions } from '@vltpkg/error-cause'
-import type { PostcssNode } from '@vltpkg/dss-parser'
-
-/**
- * The source text of a selector node. Parsed nodes hold references to
- * their parents, so they can never be used as an error `found` value:
- * printing one dumps the entire circular selector tree.
- */
-export const selectorText = (node: PostcssNode): string => {
-  // parsed nodes stringify back to their source. anything else (a
-  // hand-built node in a test, say) only has its value to go on.
-  const text =
-    node.toString === Object.prototype.toString ?
-      ''
-      // postcss escapes characters it does not expect in a value, e.g.
-      // the leading `.` of `.dev`, which parses as an escaped tag.
-    : String(node).trim().replace(/\\(.)/g, '$1')
-  return text || (node.value ?? node.type)
-}
-
-/**
- * A query syntax error, carrying the offending selector as a string and
- * an `EQUERY` code so the CLI can print it as a usage problem instead
- * of an internal failure.
- */
-export const queryError = (
-  message: string,
-  node: PostcssNode,
-  extra?: Pick<ErrorCauseOptions, 'wanted' | 'validOptions'>,
-) =>
-  error(message, {
-    code: 'EQUERY',
-    found: selectorText(node),
-    ...extra,
-  })
-
-/**
- * Number of single-character edits between two strings, capped at
- * `max` so a long list of candidates stays cheap to scan.
- */
-const distance = (a: string, b: string, max: number): number => {
-  if (Math.abs(a.length - b.length) > max) return max + 1
-  let prev = Array.from({ length: b.length + 1 }, (_, i) => i)
-  for (let i = 1; i <= a.length; i++) {
-    const row = [i]
-    let best = i
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1
-      /* c8 ignore next 5 -- indexes are always in range here */
-      const d = Math.min(
-        (row[j - 1] ?? 0) + 1,
-        (prev[j] ?? 0) + 1,
-        (prev[j - 1] ?? 0) + cost,
-      )
-      row.push(d)
-      if (d < best) best = d
-    }
-    if (best > max) return max + 1
-    prev = row
-  }
-  /* c8 ignore next -- the loop always fills the last cell */
-  return prev[b.length] ?? max + 1
-}
-
-/**
- * Candidates that are a typo away from `value`, closest first.
- */
-export const didYouMean = (
-  value: string,
-  candidates: Iterable<string>,
-  max = 2,
-): string[] =>
-  [...candidates]
-    .map(c => [c, distance(value, c, max)] as const)
-    .filter(([, d]) => d <= max)
-    .sort(([a, x], [b, y]) => x - y || a.localeCompare(b, 'en'))
-    .map(([c]) => c)

package/src/id.ts

@@ -1,46 +0,0 @@
-import { asIdentifierNode } from '@vltpkg/dss-parser'
-import { error } from '@vltpkg/error-cause'
-import type { ParserState } from './types.ts'
-
-/**
- * Parse ids, e.g: `#foo`
- */
-export const id = async (
-  state: ParserState,
-): Promise<ParserState> => {
-  const { value } = asIdentifierNode(state.current)
-
-  /* c8 ignore start - should not be possible */
-  if (!value) {
-    throw error('Missing identifier name')
-  }
-  /* c8 ignore stop */
-
-  // Filter out any edges and their linked
-  // nodes if they don't match the id value
-  for (const edge of state.partial.edges) {
-    if (edge.name !== value) {
-      state.partial.edges.delete(edge)
-      if (edge.to) {
-        state.partial.nodes.delete(edge.to)
-      }
-    }
-  }
-
-  // Filter out importer nodes, this extra step is needed
-  // to filter out nodes that have no edges linking to them
-  for (const node of state.partial.nodes) {
-    if (
-      node.edgesIn.size === 0 &&
-      node.name !== value &&
-      state.partial.nodes.has(node)
-    ) {
-      state.partial.nodes.delete(node)
-    }
-  }
-
-  // Increment the idCounter for specificity
-  state.specificity.idCounter += 1
-
-  return state
-}