@nordcraft/search 1.0.93 → 1.0.95

package/src/util/contextlessEvaluateFormula.ts

@@ -38,7 +38,7 @@ export const contextlessEvaluateFormula = (
     }
 
     case 'array': {
-      const results = formula.arguments.map((arg) =>
+      const results = (formula.arguments ?? []).map((arg) =>
         contextlessEvaluateFormula(arg.formula),
       )
 
@@ -49,7 +49,7 @@ export const contextlessEvaluateFormula = (
     }
 
     case 'record': {
-      const entries = Object.entries(formula.entries).map(
+      const entries = Object.entries(formula.entries ?? {}).map(
         ([key, arg]) => [key, contextlessEvaluateFormula(arg.formula)] as const,
       )
 
@@ -68,7 +68,7 @@ export const contextlessEvaluateFormula = (
     // - ANY condition is static and falsy
     // - EMPTY argument list is always true
     case 'and': {
-      const results = formula.arguments.map((arg) =>
+      const results = (formula.arguments ?? []).map((arg) =>
         contextlessEvaluateFormula(arg.formula),
       )
 
@@ -90,7 +90,7 @@ export const contextlessEvaluateFormula = (
     // - ALL conditions are static AND falsy
     // - EMPTY argument list is always false
     case 'or': {
-      const results = formula.arguments.map((arg) =>
+      const results = (formula.arguments ?? []).map((arg) =>
         contextlessEvaluateFormula(arg.formula),
       )
 

package/src/util/parseSearchQuery.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'bun:test'
+import { parseSearchQuery } from './parseSearchQuery'
+
+describe('parseSearchQuery', () => {
+  test('it should parse simple strings as a literal', () => {
+    const result = parseSearchQuery('Some string')
+    expect(result).toHaveLength(1)
+    expect(result[0].fields).toBe('Some string')
+  })
+
+  test('it should parse case-insensitive regex', () => {
+    const result = parseSearchQuery('/some string/i')
+    expect(result).toHaveLength(1)
+    expect(result[0].fields).toBeInstanceOf(RegExp)
+    expect((result[0].fields as RegExp).source).toBe('some string')
+    expect((result[0].fields as RegExp).flags).toBe('i')
+  })
+
+  test('it should parse case-sensitive regex', () => {
+    const result = parseSearchQuery('/Some string/')
+    expect(result).toHaveLength(1)
+    expect(result[0].fields).toBeInstanceOf(RegExp)
+    expect((result[0].fields as RegExp).source).toBe('Some string')
+    expect((result[0].fields as RegExp).flags).toBe('')
+  })
+
+  test('it should parse Variable,my-var as a literal', () => {
+    const result = parseSearchQuery('Variable,my-var')
+    expect(result).toHaveLength(1)
+    expect(result[0].fields).toBe('Variable,my-var')
+  })
+
+  test('it should parse programmatic search with empty nodeType and exact match quotes', () => {
+    const result = parseSearchQuery('<>tag:"div"')
+    expect(result).toHaveLength(1)
+    expect(result[0].nodeType).toBeUndefined()
+    expect(result[0].fields).toEqual({ tag: '"div"' })
+  })
+
+  test('it should parse programmatic search with specific nodeType and exact match quotes', () => {
+    const result = parseSearchQuery('<component-node>tag:"img"')
+    expect(result).toHaveLength(1)
+    expect(result[0].nodeType).toBe('component-node')
+    expect(result[0].fields).toEqual({ tag: '"img"' })
+  })
+
+  test('it should parse programmatic search with multiple fields and regex', () => {
+    const result = parseSearchQuery('<>tag:"img" attrs.alt:"/.+/"')
+    expect(result).toHaveLength(1)
+    expect(result[0].fields).toEqual({
+      tag: '"img"',
+      'attrs.alt': expect.any(RegExp),
+    })
+    expect((result[0].fields as any)['attrs.alt'].source).toBe('.+')
+  })
+})

package/src/util/parseSearchQuery.ts

@@ -0,0 +1,92 @@
+import type { NodeType } from '../types'
+
+export type SearchQueryPart = {
+  nodeType?: NodeType['nodeType']
+  fields?: Record<string, string | RegExp> | string | RegExp
+  exclude?: boolean // -key:value or -value
+}
+
+/**
+ * Takes a string query and return a search query object.
+ *
+ * Query format examples:
+ * - `Some string` - will match exactly "some string" (case insensitive) in a field
+ * - `/some string/i` - same as the above
+ * - `/Some string/` - same as the above, but case sensitive (any regex allowed)
+ * - `Variable,my-var` - will match formula path nodes, as Arrays and objects are stringified when possible.
+ *
+ * Programmatic search only (WIP, may change):
+ * All starts with "<" and contains one ">".
+ *
+ * - `<>tag:"div"` - will return fields with key "tag" and value exactly "div"
+ * - `<component-node>tag:"img"` - same as above, but will only return nodes of type "component-node"
+ * - `<>tag:"img" attrs.alt:"/.+/"` - has field tag equals "img" and any value in field "alt" of object "attrs" on the same element.
+ * - `<formula>type:"path" path:Variable,my-var` - precisely match a formula with type "path" and path ["Variable", "my-var"] (note that arrays and objects are stringified when possible, so we can use the same syntax as the literal search for exact matches on them)
+ */
+export function parseSearchQuery(query: string): SearchQueryPart[] {
+  const trimmed = query.trim()
+  if (!trimmed) return []
+
+  // Check for programmatic search: <nodeType>field:"value" ...
+  const closingBracketIndex = trimmed.startsWith('<')
+    ? trimmed.indexOf('>')
+    : -1
+  if (closingBracketIndex > 0) {
+    const nodeTypeStr = trimmed.slice(1, closingBracketIndex).trim()
+    const fieldsPart = trimmed.slice(closingBracketIndex + 1).trim()
+
+    const nodeType = nodeTypeStr
+      ? (nodeTypeStr as NodeType['nodeType'])
+      : undefined
+    const fields: Record<string, string | RegExp> = {}
+
+    // Regex to match field:"value" or field:"/regex/flags"
+    // Modified to swallow quotes around /regex/
+    const fieldRegex =
+      /\s*([^:]+?)\s*:(?:"\/([^/]*)\/([gimuy]*)"|(?:"([^"]*)"))/gi
+    let match: RegExpExecArray | null
+    while ((match = fieldRegex.exec(fieldsPart)) !== null) {
+      const fieldName = match[1]
+      const regexPattern = match[2]
+      const regexFlags = match[3]
+      const quotedValue = match[4]
+
+      if (regexPattern !== undefined) {
+        try {
+          fields[fieldName] = new RegExp(regexPattern, regexFlags || undefined)
+        } catch {
+          fields[fieldName] = `/${regexPattern}/${regexFlags}`
+        }
+      } else if (quotedValue !== undefined) {
+        // Keep the quotes to indicate "exact match" in the rule
+        fields[fieldName] = `"${quotedValue}"`
+      }
+    }
+
+    return [{ nodeType, fields }]
+  }
+
+  // Regular text search
+  // Regex match?
+  if (trimmed.startsWith('/') && trimmed.lastIndexOf('/') > 0) {
+    const lastSlashIndex = trimmed.lastIndexOf('/')
+    const pattern = trimmed.slice(1, lastSlashIndex)
+    const flags = trimmed.slice(lastSlashIndex + 1)
+    try {
+      // If no flags provided, don't default to 'i' if user specifically provided /.../
+      // The requirement says /Some string/ is case sensitive, /some string/i is case insensitive.
+      return [{ fields: new RegExp(pattern, flags || undefined) }]
+    } catch {
+      // Fallback
+    }
+  }
+
+  // Default: literal case-insensitive match (as a regex for simple consistency with rule)
+  // The user says matches exactly "some string" (case insensitive)
+  // We use the raw string here because we want to match it exactly (not as a regex)
+  return [
+    {
+      fields: trimmed,
+    },
+  ]
+}