@vltpkg/query 1.0.0-rc.8 → 1.0.1

package/src/attribute.ts

@@ -0,0 +1,186 @@
+import { asAttributeNode } from '@vltpkg/dss-parser'
+import { error } from '@vltpkg/error-cause'
+import { removeDanglingEdges } from './pseudo/helpers.ts'
+import type { NodeLike, JSONField, Manifest } from '@vltpkg/types'
+import type { ParserState } from './types.ts'
+
+export type ComparatorFn = (attr: string, value?: string) => boolean
+
+// JSONField has a mapped type constituent that would coerce to [object Object]
+// when stringified, which is what we want in this case.
+// eslint-disable-next-line @typescript-eslint/no-base-to-string
+const jsonFieldToString = (v: JSONField) => String(v)
+
+/**
+ * Retrieve the {@link Manifest} values found at the given `properties`
+ * location for a given {@link Node}.
+ */
+export const getManifestPropertyValues = (
+  node: NodeLike,
+  properties: string[],
+  attribute: string,
+): string[] | undefined => {
+  if (!node.manifest) return
+
+  const traverse = new Set<JSONField>([node.manifest])
+  const props = new Set<JSONField>()
+  for (const key of properties) {
+    for (const prop of traverse) {
+      /* c8 ignore start - should be impossible */
+      if (!prop) {
+        throw error('failed to find nested property in :attr', {
+          found: properties,
+        })
+      }
+      /* c8 ignore stop */
+
+      // expand the result list to include nested array values
+      if (Array.isArray(prop)) {
+        for (const p of prop) {
+          traverse.add(p)
+        }
+        continue
+      }
+
+      // guard for inspecting keys of objects next
+      if (
+        typeof prop === 'string' ||
+        typeof prop === 'number' ||
+        typeof prop === 'boolean'
+      ) {
+        continue
+      }
+
+      // assign next value when found
+      if (key in prop) {
+        const nextValue = prop[key]
+        if (nextValue) {
+          if (key === attribute) {
+            props.add(nextValue)
+          } else {
+            traverse.delete(prop)
+            traverse.add(nextValue)
+          }
+        }
+      }
+    }
+  }
+  // if no value was found after trying a given key
+  // then there's nothing to be collected
+  if (!props.size) return
+
+  // expand the result to include array values
+  const collect = new Set<string>()
+  for (const prop of props) {
+    if (Array.isArray(prop)) {
+      for (const p of prop) {
+        collect.add(p ? jsonFieldToString(p) : '')
+      }
+    } else {
+      collect.add(jsonFieldToString(prop))
+    }
+  }
+
+  return [...collect]
+}
+
+// decorator style of function that will filter `ParserState` results
+// based on a provided `comparator` function
+export const filterAttributes = (
+  state: ParserState,
+  comparator: ComparatorFn | undefined,
+  value: string,
+  propertyName: string,
+  insensitive: boolean,
+  prefixProperties: string[] = [],
+): ParserState => {
+  const check = (attr: JSONField) =>
+    comparator?.(
+      insensitive ?
+        jsonFieldToString(attr).toLowerCase()
+      : jsonFieldToString(attr),
+      insensitive ? value.toLowerCase() : value,
+    )
+  const deleteNode = (node: NodeLike) => {
+    for (const edge of node.edgesIn) {
+      state.partial.edges.delete(edge)
+    }
+    state.partial.nodes.delete(node)
+  }
+
+  for (const node of state.partial.nodes) {
+    const prefixes =
+      prefixProperties.length ? prefixProperties : [propertyName]
+    const attrs = getManifestPropertyValues(
+      node,
+      prefixes,
+      propertyName,
+    )
+
+    // if no attribute value was found, that means the attribute won't match
+    if (!attrs?.length) {
+      deleteNode(node)
+      continue
+    }
+
+    // if the node attribute value won't match, then remove the node
+    if (comparator && !attrs.some(check)) {
+      deleteNode(node)
+    }
+  }
+
+  removeDanglingEdges(state)
+  return state
+}
+
+// ref: https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors
+const attributeSelectors: Record<string, ComparatorFn> = {
+  '=': (attr: string, value = '') => attr === value,
+  '^=': (attr: string, value = '') => attr.startsWith(value),
+  '$=': (attr: string, value = '') => attr.endsWith(value),
+  '~=': (attr: string, value = '') =>
+    new Set<string>(attr.match(/\w+/g)).has(value),
+  '*=': (attr: string, value = '') => attr.includes(value),
+  '|=': (attr: string, value = '') =>
+    attr === value || attr.startsWith(`${value}-`),
+  undefined: (attr: string) => !!attr,
+}
+export const attributeSelectorsMap = new Map<string, ComparatorFn>(
+  Object.entries(attributeSelectors),
+)
+
+/**
+ * Parse attributes selectors, e.g: `[name]`, `[name=value]`, etc
+ */
+export const attribute = async (
+  state: ParserState,
+): Promise<ParserState> => {
+  await state.cancellable()
+
+  const curr = asAttributeNode(state.current)
+  const operatorFn = attributeSelectorsMap.get(String(curr.operator))
+  if (!operatorFn) {
+    if (state.loose) {
+      return state
+    }
+
+    throw error(`Unsupported attribute operator: ${curr.operator}`, {
+      found: state.current,
+    })
+  }
+
+  const value = curr.value || ''
+  const propertyName = curr.attribute
+  const insensitive = !!curr.insensitive
+
+  // Increment the commonCounter for specificity
+  state.specificity.commonCounter += 1
+
+  return filterAttributes(
+    state,
+    operatorFn,
+    value,
+    propertyName,
+    insensitive,
+  )
+}

package/src/combinator.ts

@@ -0,0 +1,132 @@
+import { asCombinatorNode } from '@vltpkg/dss-parser'
+import { error } from '@vltpkg/error-cause'
+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,
+}
+
+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 error(`Unsupported combinator: ${state.current.value}`, {
+      found: state.current,
+    })
+  }
+  return parserFn(state)
+}

package/src/id.ts

@@ -0,0 +1,46 @@
+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
+}