import { SuperSelector } from 'super-selector'

// V2 Instance API (Recommended)
const selector = new SuperSelector({ debug: true, cacheEnabled: true })
const result = await selector.execute("div.content | textContent | trim()", document)

// V1 Compatibility API (Still works)
const text = await SuperSelector.superSelector("div.content | textContent", document)
const element = await SuperSelector.findElement("div.my-class", document)

"CSS_SELECTOR | PROPERTY_ACCESS | FUNCTION_CALL | ARRAY_ACCESS"

// CSS Selector → Property Access
"div.user-info | textContent"

// CSS Selector → Function Call → Array Access
"ul li | getAttribute('data-id') | [0]"

// Complex Chain
"table tbody tr | [1] | querySelector('td') | textContent | trim()"

// Built-in Helper Functions
"div.items | getProp('dataset') | p('itemId')"

const selector = new SuperSelector({
debug: true,                    // Enable debug logging
cacheEnabled: true,            // Enable result caching
cacheTTL: 60000,              // Cache TTL in milliseconds
timeout: 5000,                // Execution timeout
maxDepth: 50,                 // Maximum execution depth
errorHandling: 'return-null', // Error handling strategy
defaultValue: null,           // Default return value
})

// Return null on errors (default)
selector.configure({ errorHandling: 'return-null' })

// Return custom default value
selector.configure({
errorHandling: 'return-default',
defaultValue: 'N/A'
})

// Throw errors
selector.configure({ errorHandling: 'throw' })

// Listen to execution events
selector.on('execution:start', (data) => {
console.log('Execution started:', data.commands)
})

selector.on('execution:complete', (data) => {
console.log('Execution completed in:', data.executionTime, 'ms')
})

selector.on('execution:error', (data) => {
console.error('Execution failed:', data.error)
})

// Enable caching
selector.configure({ cacheEnabled: true, cacheTTL: 30000 })

// Get cache statistics
const stats = selector.getCacheStats()
console.log('Cache hits:', stats.totalHits)

// Clear cache
selector.clearCache()

import type { Plugin, CommandHandler } from 'super-selector'

const myPlugin: Plugin = {
name: 'my-custom-plugin',
version: '1.0.0',

commands: {
// Custom command
'customFilter': {
execute(context, filterFn) {
const { currentValue } = context
if (Array.isArray(currentValue)) {
return currentValue.filter(eval(filterFn))
}
return currentValue
},
validate(args) {
return args.length === 1 && typeof args[0] === 'string'
},
description: 'Filter array elements with custom function'
}
},

hooks: {
'execution:start': (context) => {
console.log('Plugin: Execution starting')
}
},

initialize(config) {
console.log('Plugin initialized with config:', config)
}
}

// Load the plugin
selector.loadPlugin(myPlugin)

// Use the custom command
const result = await selector.execute(
"div.items | customFilter('item => item.active')",
document
)

// Load plugin
selector.loadPlugin(myPlugin)

// Unload plugin
selector.unloadPlugin('my-custom-plugin')

// List loaded plugins
const plugins = selector.getLoadedPlugins()

// List available commands
const commands = selector.getAvailableCommands()

// Direct property access
"element | propertyName"

// getProp function (works with arrays)
"elements | getProp('textContent')"

// Alias 'p' for getProp
"elements | p('dataset') | p('id')"

// Array access by index
"elements | [0]"          // First element
"elements | [-1]"         // Last element

// Property access on arrays
"elements | textContent"  // Gets textContent from all elements

// Native string methods
"element | textContent | trim()"
"element | textContent | toLowerCase()"
"element | getAttribute('href') | replace('http', 'https')"

// Property includes (case-sensitive)
"elements | propIncludes('className', 'active')"

// Property includes (case-insensitive)
"elements | propIncludesLowercase('textContent', 'hello')"

// Regex matching
"elements | matchProp('textContent', '^\\d+$')"

// Recursive property access
"element | recursiveProp('parentElement', 3)"

import { SuperSelector } from 'super-selector'

class ContentScraper {
private selector = new SuperSelector({
debug: false,
cacheEnabled: true,
cacheTTL: 30000
})

async getProductInfo() {
return {
title: await this.selector.execute(
"h1.product-title | textContent | trim()",
document
),
price: await this.selector.execute(
".price-current | textContent | matchProp('textContent', '\\$[\\d,.]+')",
document
),
images: await this.selector.execute(
".product-images img | p('src')",
document
),
reviews: await this.selector.execute(
".review-item | p('textContent') | [0:5]",
document
)
}
}

async monitorPriceChanges(callback) {
const observer = new MutationObserver(async () => {
const newPrice = await this.selector.execute(
".price-current | textContent",
document
)
callback(newPrice)
})

    observer.observe(document.body, {
      childList: true,
      subtree: true
    })
}
}

class DashboardMonitor {
private selector = new SuperSelector({ debug: true })

constructor() {
// Listen for execution events
this.selector.on('execution:complete', (data) => {
if (data.executionTime > 1000) {
console.warn('Slow execution detected:', data.executionTime, 'ms')
}
})
}

async getMetrics() {
const metrics = await Promise.all([
this.selector.execute(".metric-users | p('textContent') | parseInt()", document),
this.selector.execute(".metric-revenue | p('textContent') | parseFloat()", document),
this.selector.execute(".metric-conversion | p('textContent')", document)
])

    return {
      users: metrics[0].value,
      revenue: metrics[1].value,
      conversion: metrics[2].value
    }
}

async getTableData() {
return this.selector.execute(`
      table.data-table tbody tr | 
      p('cells') | 
      p('textContent')
    `, document)
}
}

class EcommerceScraper {
private selector = new SuperSelector({
cacheEnabled: true,
errorHandling: 'return-default',
defaultValue: 'N/A'
})

async scrapeProductList() {
const products = await this.selector.execute(
".product-grid .product-item",
document
)

    if (!Array.isArray(products.value)) return []

    return Promise.all(
      products.value.map(async (product) => ({
        name: await this.selector.execute("h3.product-name | textContent", product),
        price: await this.selector.execute(".price | textContent | matchProp('textContent', '\\$[\\d,.]+')", product),
        rating: await this.selector.execute(".rating | p('dataset') | p('rating')", product),
        image: await this.selector.execute("img | getAttribute('src')", product),
        link: await this.selector.execute("a | getAttribute('href')", product)
      }))
    )
}

async getProductDetails(productUrl) {
// Navigate to product page first
window.location.href = productUrl

    await new Promise(resolve => setTimeout(resolve, 1000)) // Wait for page load

    return {
      title: await this.selector.execute("h1.product-title | textContent", document),
      description: await this.selector.execute(".product-description | textContent", document),
      specifications: await this.selector.execute(
        ".specs-table tr | p('textContent')", 
        document
      ),
      reviews: await this.selector.execute(
        ".review-list .review | p('textContent') | [0:10]", 
        document
      )
    }
}
}

new SuperSelector(config?: Partial<SuperSelectorConfig>)

interface SuperSelectorConfig {
debug: boolean                    // Enable debug logging
timeout: number                   // Execution timeout (ms)
maxDepth: number                  // Maximum execution depth
cacheEnabled: boolean             // Enable result caching
cacheTTL: number                  // Cache time-to-live (ms)
errorHandling: 'throw' | 'return-null' | 'return-default'
defaultValue: any                 // Default value for errors
plugins: string[]                 // Plugin names to auto-load
customCommands: Record<string, CommandHandler>
}

import { SuperSelector } from 'super-selector'

describe('My SuperSelector Tests', () => {
let selector: SuperSelector

beforeEach(() => {
document.body.innerHTML = `
      <div id="test-container">
        <p class="text">Hello World</p>
      </div>
    `
selector = new SuperSelector({ debug: true })
})

afterEach(() => {
selector.destroy()
})

it('should execute basic selector', async () => {
const result = await selector.execute('#test-container .text | textContent')
expect(result.success).toBe(true)
expect(result.value).toBe('Hello World')
})
})

import { SuperSelector } from 'super-selector'

const result = SuperSelector.superSelector("div | textContent", document)
const element = SuperSelector.findElement("div.class", document)

import { SuperSelector } from 'super-selector'

// Create configured instance
const selector = new SuperSelector({
debug: true,
cacheEnabled: true,
errorHandling: 'return-default',
defaultValue: 'N/A'
})

// Use async/await with detailed results
const result = await selector.execute("div | textContent", document)
console.log('Success:', result.success)
console.log('Value:', result.value)
console.log('Execution time:', result.metadata.executionTime, 'ms')