chore: import upstream snapshot with attribution

apps/sim/lib/workflows/search-replace/resources/resolvers.ts

@@ -0,0 +1,192 @@
+import type {
+  WorkflowSearchMatch,
+  WorkflowSearchMatchKind,
+  WorkflowSearchReplacementOption,
+  WorkflowSearchResourceMeta,
+  WorkflowSearchValuePath,
+} from '@/lib/workflows/search-replace/types'
+import type { SelectorContext } from '@/hooks/selectors/types'
+
+const OVERLAPPING_MATCH_KIND_PRIORITY: Record<WorkflowSearchMatchKind, number> = {
+  text: 0,
+  environment: 1,
+  'workflow-reference': 2,
+  'oauth-credential': 3,
+  'knowledge-base': 3,
+  'knowledge-document': 3,
+  workflow: 3,
+  'mcp-server': 3,
+  'mcp-tool': 3,
+  table: 3,
+  file: 3,
+  'selector-resource': 3,
+}
+
+export function stableStringifyWorkflowSearchValue(value: unknown): string {
+  if (!value || typeof value !== 'object') return JSON.stringify(value)
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringifyWorkflowSearchValue(item)).join(',')}]`
+  }
+
+  return `{${Object.entries(value as Record<string, unknown>)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringifyWorkflowSearchValue(item)}`)
+    .join(',')}}`
+}
+
+export function buildWorkflowSearchResourceGroupKey(
+  resource: Pick<
+    WorkflowSearchResourceMeta,
+    'kind' | 'providerId' | 'serviceId' | 'selectorKey' | 'selectorContext'
+  >
+): string {
+  const provider = resource.providerId ?? resource.serviceId ?? ''
+  const selectorKey = resource.selectorKey ?? ''
+  const selectorContext = resource.selectorContext
+    ? stableStringifyWorkflowSearchValue(resource.selectorContext)
+    : ''
+
+  return [resource.kind, provider, selectorKey, selectorContext].join(':')
+}
+
+export function getWorkflowSearchMatchResourceGroupKey(match: WorkflowSearchMatch): string {
+  return (
+    match.resource?.resourceGroupKey ??
+    buildWorkflowSearchResourceGroupKey({
+      kind: match.kind as WorkflowSearchResourceMeta['kind'],
+      providerId: match.resource?.providerId,
+      serviceId: match.resource?.serviceId,
+      selectorKey: match.resource?.selectorKey,
+      selectorContext: match.resource?.selectorContext,
+    })
+  )
+}
+
+export function selectorContextMatches(
+  left: SelectorContext | undefined,
+  right: SelectorContext | undefined
+): boolean {
+  return (
+    stableStringifyWorkflowSearchValue(left ?? {}) ===
+    stableStringifyWorkflowSearchValue(right ?? {})
+  )
+}
+
+export function replacementOptionMatchesResourceMatch(
+  option: WorkflowSearchReplacementOption,
+  match: WorkflowSearchMatch
+): boolean {
+  if (option.kind !== match.kind) return false
+
+  const optionGroupKey =
+    option.resourceGroupKey ??
+    buildWorkflowSearchResourceGroupKey({
+      kind: option.kind as WorkflowSearchResourceMeta['kind'],
+      providerId: option.providerId,
+      serviceId: option.serviceId,
+      selectorKey: option.selectorKey,
+      selectorContext: option.selectorContext,
+    })
+
+  return optionGroupKey === getWorkflowSearchMatchResourceGroupKey(match)
+}
+
+export function getWorkflowSearchCompatibleResourceMatches(
+  activeMatch: WorkflowSearchMatch | null,
+  matches: WorkflowSearchMatch[]
+): WorkflowSearchMatch[] {
+  if (!activeMatch?.resource) return []
+  const activeGroupKey = getWorkflowSearchMatchResourceGroupKey(activeMatch)
+  return matches.filter(
+    (match) =>
+      match.editable &&
+      Boolean(match.resource) &&
+      getWorkflowSearchMatchResourceGroupKey(match) === activeGroupKey
+  )
+}
+
+function searchValuePathKey(path: WorkflowSearchValuePath): string {
+  return path.map((segment) => `${typeof segment}:${String(segment)}`).join('/')
+}
+
+function getRangeMatchScopeKey(match: WorkflowSearchMatch): string | null {
+  if (!match.range) return null
+  if (match.target.kind !== 'subblock') return null
+  return [match.blockId, match.subBlockId, searchValuePathKey(match.valuePath)].join(':')
+}
+
+function rangesOverlap(
+  left: NonNullable<WorkflowSearchMatch['range']>,
+  right: NonNullable<WorkflowSearchMatch['range']>
+): boolean {
+  return left.start < right.end && right.start < left.end
+}
+
+function getRangeLength(match: WorkflowSearchMatch): number {
+  return match.range ? match.range.end - match.range.start : Number.POSITIVE_INFINITY
+}
+
+function shouldPreferOverlappingMatch(
+  candidate: WorkflowSearchMatch,
+  current: WorkflowSearchMatch
+): boolean {
+  const candidateLength = getRangeLength(candidate)
+  const currentLength = getRangeLength(current)
+  if (candidateLength !== currentLength) return candidateLength < currentLength
+
+  const candidatePriority = OVERLAPPING_MATCH_KIND_PRIORITY[candidate.kind]
+  const currentPriority = OVERLAPPING_MATCH_KIND_PRIORITY[current.kind]
+  if (candidatePriority !== currentPriority) return candidatePriority > currentPriority
+
+  return false
+}
+
+export function dedupeOverlappingWorkflowSearchMatches<T extends WorkflowSearchMatch>(
+  matches: T[]
+): T[] {
+  const deduped: T[] = []
+
+  for (const match of matches) {
+    const scopeKey = getRangeMatchScopeKey(match)
+    const matchRange = match.range
+    const existingIndex =
+      scopeKey && matchRange
+        ? deduped.findIndex(
+            (candidate) =>
+              getRangeMatchScopeKey(candidate) === scopeKey &&
+              candidate.range &&
+              rangesOverlap(candidate.range, matchRange)
+          )
+        : -1
+
+    if (existingIndex === -1) {
+      deduped.push(match)
+      continue
+    }
+
+    if (shouldPreferOverlappingMatch(match, deduped[existingIndex])) {
+      deduped[existingIndex] = match
+    }
+  }
+
+  return deduped
+}
+
+export function workflowSearchMatchMatchesQuery(
+  match: WorkflowSearchMatch & { displayLabel?: string },
+  query: string,
+  caseSensitive = false
+): boolean {
+  const trimmedQuery = query.trim()
+  if (!trimmedQuery) return false
+  if (match.kind === 'text') return true
+
+  const normalize = (value: string) => (caseSensitive ? value : value.toLowerCase())
+  const searchable =
+    match.resource?.kind === 'workflow-reference' || match.resource?.kind === 'environment'
+      ? [match.displayLabel, match.rawValue, match.searchText]
+      : [match.displayLabel]
+  const searchableText = searchable.filter(Boolean).join(' ')
+
+  return normalize(searchableText).includes(normalize(trimmedQuery))
+}