assign-gingerly 0.0.30 → 0.0.31

package/README.md

@@ -1,4 +1,4 @@
-# assign-gingerly and assign-tentatively
+# assign-gingerly and assign-tentatively
 
 [![Playwright Tests](https://github.com/bahrus/assign-gingerly/actions/workflows/CI.yml/badge.svg?branch=baseline)](https://github.com/bahrus/assign-gingerly/actions/workflows/CI.yml)
 [![NPM version](https://badge.fury.io/js/assign-gingerly.png)](http://badge.fury.io/js/assign-gingerly)
@@ -1460,19 +1460,19 @@ element.remove();
 
 // Case 1: Temporarily removed, will be re-added
 setTimeout(() => document.body.append(element), 1000);
-// ❌ Don't dispose - enhancement should persist
+// ? Don't dispose - enhancement should persist
 
 // Case 2: Moved to another location
 otherContainer.append(element);
-// ❌ Don't dispose - enhancement should persist
+// ? Don't dispose - enhancement should persist
 
 // Case 3: Cached for reuse
 elementCache.set('myElement', element);
-// ❌ Don't dispose - enhancement should persist
+// ? Don't dispose - enhancement should persist
 
 // Case 4: Truly done, ready for GC
 element = null;
-// ✅ Should dispose, but no way to detect this automatically
+// ? Should dispose, but no way to detect this automatically
 ```
 
 **Practical disposal strategies:**
@@ -1566,10 +1566,10 @@ class MyEnhancement {
 ```
 
 **Summary:**
-- ✅ Storage mechanism prevents memory leaks via WeakMap
-- ⚠️ Enhancement internals need manual cleanup via dispose()
-- ❌ No automatic way to detect when disposal should happen
-- 👍 Choose disposal strategy based on your application's lifecycle
+- ? Storage mechanism prevents memory leaks via WeakMap
+- ?? Enhancement internals need manual cleanup via dispose()
+- ? No automatic way to detect when disposal should happen
+- ?? Choose disposal strategy based on your application's lifecycle
 
 ### Waiting for Async Initialization with `enh.whenResolved(regItem)`
 
@@ -1976,7 +1976,7 @@ console.log(instance.value);  // 'test123' (parsed from attribute)
 
 </details>
 
-> ![NOTE]
+> [!NOTE]
 > `withAttrs` works with or without `enhKey`. When there's no `enhKey`, the parsed attributes are passed directly to the constructor. When there is an `enhKey`, they're merged with any pre-existing values on the enh container.
 
 ### The `enh-` Prefix for Attribute Isolation
@@ -2150,7 +2150,7 @@ The `base` attribute must contain either a dash (`-`) or a non-ASCII character t
 ```TypeScript
 // Valid base attributes
 const enhConfig1 = { base: 'data-config' };     // Has dash
-const enhConfig2 =  { base: '🎨-theme' });        // Has non-ASCII (and dash)
+const enhConfig2 =  { base: '??-theme' });        // Has non-ASCII (and dash)
 
 // Invalid - throws error
 const enhConig3 = { base: 'config' };          // No dash or non-ASCII
@@ -2198,6 +2198,33 @@ const result = parseWithAttrs(element, {
 // Result: { name: 'Alice', age: '30' }
 ```
 
+**Deep Nesting:**
+
+Template variables can reference other template variables to any depth, creating hierarchical attribute naming patterns:
+
+```TypeScript
+// HTML: <div data-app-user-profile-name="Alice" data-app-user-profile-email="alice@example.com"></div>
+
+const result = parseWithAttrs(element, {
+  base: 'data-',
+  app: '${base}app',
+  user: '${app}-user',
+  profile: '${user}-profile',
+  name: '${profile}-name',
+  email: '${profile}-email'
+});
+// Result: { name: 'Alice', email: 'alice@example.com' }
+
+// The resolution chain: base ? app ? user ? profile ? name/email
+// Resolves to: data-app-user-profile-name and data-app-user-profile-email
+```
+
+**Benefits of hierarchical variables:**
+- Build complex attribute names from simple parts
+- Maintain consistency across related attributes
+- Easy to refactor by changing a single variable
+- Self-documenting attribute structure
+
 Template variables are resolved recursively and cached for performance. Circular references are detected and throw an error.
 
 ### Type Parsing with instanceOf
@@ -2376,12 +2403,12 @@ registerCommonParsers(globalParserRegistry);
 
 **Benefits of Named Parsers:**
 
-- ✅ **JSON serializable** - Configs can be stored/transmitted as JSON
-- ✅ **Reusable** - Define once, use everywhere
-- ✅ **Maintainable** - Update parser logic in one place
-- ✅ **Testable** - Test parsers independently
-- ✅ **Discoverable** - `globalParserRegistry.getNames()` lists all available parsers
-- ✅ **Backward compatible** - Inline functions still work
+- ? **JSON serializable** - Configs can be stored/transmitted as JSON
+- ? **Reusable** - Define once, use everywhere
+- ? **Maintainable** - Update parser logic in one place
+- ? **Testable** - Test parsers independently
+- ? **Discoverable** - `globalParserRegistry.getNames()` lists all available parsers
+- ? **Backward compatible** - Inline functions still work
 
 **Mixing Inline and Named Parsers:**
 
@@ -3408,315 +3435,3 @@ ItemScope Managers follow these design principles:
 
 This design ensures backward compatibility while providing powerful new capabilities for managing DOM fragments.
 
-
-
-
-## Smart Value Assignment with Infer Enhancement
-
-The Infer enhancement provides a symbol-based API for smart value and display property assignment. Instead of manually determining which property to set on different element types (e.g., `value` for inputs, `checked` for checkboxes, `textContent` for divs), the Infer enhancement automatically infers the correct property based on the element type.
-
-### Why Infer?
-
-Different HTML elements use different properties to represent their value:
-- Input text fields use `value`
-- Checkboxes and radio buttons use `checked`
-- Time elements use `dateTime`
-- Divs and spans use `textContent`
-- Progress and meter elements use `value` but display with `ariaValueText`
-
-The Infer enhancement eliminates the need to remember these differences by providing two symbols that automatically map to the correct property:
-
-- `value` symbol - Sets the element's data value
-- `display` symbol - Sets the element's display/presentation value
-
-### Basic Usage
-
-```TypeScript
-import { value, display, registryItem } from 'assign-gingerly/Infer.js';
-import 'assign-gingerly/object-extension.js';
-
-// Register the Infer enhancement
-customElements.enhancementRegistry.push(registryItem);
-
-// Use the value symbol - automatically sets the right property
-const input = document.createElement('input');
-input.type = 'text';
-input.set[value] = 'hello';
-console.log(input.value); // 'hello'
-
-const checkbox = document.createElement('input');
-checkbox.type = 'checkbox';
-checkbox.set[value] = true;
-console.log(checkbox.checked); // true
-
-const div = document.createElement('div');
-div.set[value] = 'content';
-console.log(div.textContent); // 'content'
-
-const time = document.createElement('time');
-time.set[value] = '2024-01-01T00:00:00Z';
-console.log(time.dateTime); // '2024-01-01T00:00:00Z'
-```
-
-### Value Property Inference
-
-The `value` symbol automatically maps to the most appropriate property for each element type:
-
-| Element Type | Property Set | Example |
-|-------------|-------------|---------|
-| `<input type="text">` | `value` | Text input value |
-| `<input type="checkbox">` | `checked` | Checkbox state |
-| `<input type="radio">` | `checked` | Radio button state |
-| `<textarea>` | `value` | Textarea content |
-| `<select>` | `value` | Selected option |
-| `<time>` | `dateTime` | ISO datetime string |
-| `<data>` | `value` | Machine-readable value |
-| `<meter>` | `value` | Numeric value |
-| `<progress>` | `value` | Progress value |
-| `<output>` | `value` | Output value |
-| Elements with `itemprop` | `itemprop` value | Custom property name |
-| Other elements | `textContent` | Text content |
-
-### Display Property Inference
-
-The `display` symbol sets the human-readable display value:
-
-```TypeScript
-// Time element - display formatted time
-const time = document.createElement('time');
-time.set[value] = '2024-01-01T00:00:00Z';  // Machine-readable
-time.set[display] = 'January 1, 2024';      // Human-readable
-console.log(time.dateTime);    // '2024-01-01T00:00:00Z'
-console.log(time.textContent); // 'January 1, 2024'
-
-// Meter element - display with ARIA
-const meter = document.createElement('meter');
-meter.min = 0;
-meter.max = 100;
-meter.set[value] = 75;                    // Numeric value
-meter.set[display] = '75 percent';        // Screen reader text
-console.log(meter.value);          // 75
-console.log(meter.ariaValueText);  // '75 percent'
-```
-
-| Element Type | Property Set | Example |
-|-------------|-------------|---------|
-| `<input>`, `<textarea>`, `<select>` | `value` | Form control value |
-| `<time>` | `textContent` | Formatted time string |
-| `<data>` | `textContent` | Human-readable content |
-| `<meter>`, `<progress>` | `ariaValueText` | Screen reader text |
-| Other elements | `textContent` | Text content |
-
-### Accessing the Enhancement Instance
-
-The Infer enhancement is accessible via `element.enh.infer`:
-
-```TypeScript
-const input = document.createElement('input');
-input.set[value] = 'test';
-
-// Access the enhancement instance
-console.log(input.enh.infer.value); // 'test' (cached value)
-
-// The instance maintains references to both value and display
-input.set[display] = 'Test Display';
-console.log(input.enh.infer.value);   // 'test'
-console.log(input.enh.infer.display); // 'Test Display'
-```
-
-### Using with assignGingerly
-
-The Infer enhancement integrates seamlessly with `assignGingerly`:
-
-```TypeScript
-import { value, display } from 'assign-gingerly/Infer.js';
-
-const element = document.createElement('input');
-element.type = 'text';
-
-// Use symbols in assignGingerly
-element.assignGingerly({
-  [value]: 'hello world',
-  style: {
-    color: 'blue'
-  }
-});
-
-console.log(element.value);       // 'hello world'
-console.log(element.style.color); // 'blue'
-```
-
-### Itemprop Support
-
-Elements with an `itemprop` attribute use that attribute's value as the property name:
-
-```html
-<span itemprop="title"></span>
-```
-
-```TypeScript
-const span = document.querySelector('[itemprop="title"]');
-span.set[value] = 'My Title';
-console.log(span.title); // 'My Title'
-```
-
-### Implementation Details
-
-The Infer enhancement is implemented as a standard enhancement class:
-
-```TypeScript
-class Infer<TValue = any, TDisplay = any> {
-  #weakRef: WeakRef<Element>;
-  
-  constructor(enhancedElement?: Element) {
-    this.#weakRef = new WeakRef(enhancedElement!);
-  }
-  
-  get value(): TValue | undefined { /* ... */ }
-  set value(nv: TValue) {
-    const element = this.#weakRef.deref()!;
-    element[inferValueProperty(element)] = nv;
-  }
-  
-  get display(): TDisplay | undefined { /* ... */ }
-  set display(nv: TDisplay) {
-    const element = this.#weakRef.deref()!;
-    element[inferDisplayProperty(element)] = nv;
-  }
-}
-```
-
-**Registry Configuration:**
-
-```TypeScript
-export const registryItem: EnhancementConfig = {
-  spawn: Infer,
-  enhKey: 'infer',
-  symlinks: {
-    [value]: 'value',
-    [display]: 'display'
-  }
-};
-```
-
-The `symlinks` mapping connects the symbols to the enhancement's properties, enabling the `element.set[symbol]` syntax.
-
-### Helper Functions
-
-The Infer module exports helper functions for manual property and event type inference:
-
-```TypeScript
-import { inferValueProperty, inferDisplayProperty, inferEventType } from 'assign-gingerly/Infer.js';
-
-const input = document.createElement('input');
-input.type = 'checkbox';
-
-const valueProp = inferValueProperty(input);
-console.log(valueProp); // 'checked'
-
-const displayProp = inferDisplayProperty(input);
-console.log(displayProp); // 'value'
-
-const eventType = inferEventType(input);
-console.log(eventType); // 'input'
-```
-
-These functions can be useful when you need to determine the property or event type name without actually setting a value or attaching a listener.
-
-**Event Type Inference:**
-
-The `inferEventType` function returns the most appropriate event type for different element types:
-
-| Element Type | Event Type | Use Case |
-|-------------|-----------|----------|
-| `<input>`, `<textarea>`, `<select>` | `input` | Form control value changes |
-| `<form>` | `submit` | Form submission |
-| `<details>` | `toggle` | Details element open/close |
-| `<dialog>` | `close` | Dialog dismissal |
-| Other elements | `click` | Default interactive event |
-
-**Accessing via Enhancement Instance:**
-
-The inferred event type is also available as a getter on the enhancement instance:
-
-```TypeScript
-const input = document.createElement('input');
-input.set[value] = 'test';
-
-console.log(input.enh.infer.eventType); // 'input'
-
-const form = document.createElement('form');
-form.set[value] = 'test';
-
-console.log(form.enh.infer.eventType); // 'submit'
-```
-
-This is particularly useful when building enhancements that need to attach event listeners but don't know the element type in advance.
-
-### Benefits
-
-1. **Type-agnostic code**: Write code that works with any element type without conditionals
-2. **Cleaner syntax**: No need to remember which property each element type uses
-3. **Accessibility**: Separate value and display properties support screen readers
-4. **Framework-friendly**: Symbols work well with reactive frameworks and data binding
-5. **Extensible**: Based on the enhancement registry system, can be customized or extended
-
-### Complete Example
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <script type="module">
-    import { value, display, registryItem } from './Infer.js';
-    import './object-extension.js';
-    
-    // Register the enhancement
-    customElements.enhancementRegistry.push(registryItem);
-    
-    // Create various elements
-    const input = document.createElement('input');
-    input.type = 'text';
-    
-    const checkbox = document.createElement('input');
-    checkbox.type = 'checkbox';
-    
-    const time = document.createElement('time');
-    
-    const meter = document.createElement('meter');
-    meter.min = 0;
-    meter.max = 100;
-    
-    // Set values using the same symbol - each element handles it correctly
-    input.set[value] = 'Hello World';
-    checkbox.set[value] = true;
-    time.set[value] = '2024-01-01T00:00:00Z';
-    time.set[display] = 'January 1, 2024';
-    meter.set[value] = 75;
-    meter.set[display] = '75 percent';
-    
-    // Add to document
-    document.body.append(input, checkbox, time, meter);
-    
-    console.log('Input value:', input.value);           // 'Hello World'
-    console.log('Checkbox checked:', checkbox.checked); // true
-    console.log('Time dateTime:', time.dateTime);       // '2024-01-01T00:00:00Z'
-    console.log('Time display:', time.textContent);     // 'January 1, 2024'
-    console.log('Meter value:', meter.value);           // 75
-    console.log('Meter display:', meter.ariaValueText); // '75 percent'
-  </script>
-</head>
-<body>
-  <h1>Infer Enhancement Demo</h1>
-</body>
-</html>
-```
-
-### Browser Support
-
-The Infer enhancement requires:
-- Chrome 146+ (for scoped custom element registries)
-- Modern browsers with Symbol support
-- WeakRef support (all modern browsers)
-
-For browsers without scoped registry support, the enhancement falls back to the global `customElements.enhancementRegistry`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -55,10 +55,6 @@
     "./getHost.js": {
       "default": "./getHost.js",
       "types": "./getHost.ts"
-    },
-    "./Infer.js": {
-      "default": "./Infer.js",
-      "types": "./Infer.ts"
     }
   },
   "main": "index.js",
@@ -73,7 +69,7 @@
   "devDependencies": {
     "@playwright/test": "1.59.1",
     "spa-ssi": "0.0.27",
-    "@types/node": "25.5.2",
-    "typescript": "6.0.2"
+    "@types/node": "25.6.0",
+    "typescript": "6.0.3"
   }
 }

package/playwright.config.ts

@@ -20,7 +20,7 @@ export default defineConfig({
   /* Opt out of parallel tests on CI. */
   workers: process.env.CI ? 1 : undefined,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: [ ['html', { open: 'never' }] ],
+  reporter: [ ['html', { open: 'never' }] ], 
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Base URL to use in actions like `await page.goto('/')`. */

package/types/assign-gingerly/types.d.ts

@@ -298,6 +298,7 @@ export declare function assignGingerly(
 export default assignGingerly;
 
 export declare class ElementEnhancementGateway{
+  //TODO:  this isn't right
   enh: ElementEnhancement;
 }
 

package/Infer.js

@@ -1,154 +0,0 @@
-/**
- * Symbol for smart value assignment
- * When used with element.set[value], it infers and sets the appropriate value property
- */
-export const value = Symbol.for('assign-gingerly:value');
-/**
- * Symbol for smart display assignment
- * When used with element.set[display], it infers and sets the appropriate display property
- */
-export const display = Symbol.for('assign-gingerly:display');
-/**
- * Enhancement class that provides smart value and display property inference
- * Automatically determines the correct property to set based on element type
- */
-export class Infer {
-    #weakRef;
-    get enhancedElement() {
-        return this.#weakRef.deref();
-    }
-    constructor(enhancedElement) {
-        this.#weakRef = new WeakRef(enhancedElement);
-    }
-    #value;
-    get value() {
-        return this.#value;
-    }
-    set value(nv) {
-        this.#value = nv;
-        const { enhancedElement } = this;
-        enhancedElement[inferValueProperty(enhancedElement)] = nv;
-    }
-    #display;
-    get display() {
-        return this.#display;
-    }
-    set display(nv) {
-        this.#display = nv;
-        const { enhancedElement } = this;
-        enhancedElement[inferDisplayProperty(enhancedElement)] = nv;
-    }
-    /**
-     * Get the inferred event type for the element
-     * @returns The most appropriate event type for this element
-     */
-    get eventType() {
-        return inferEventType(this.enhancedElement);
-    }
-}
-/**
- * Registry item for the Infer enhancement
- * Register this with customElements.enhancementRegistry to enable smart value/display assignment
- */
-export const registryItem = {
-    spawn: Infer,
-    enhKey: 'infer',
-    symlinks: {
-        [value]: 'value',
-        [display]: 'display'
-    }
-};
-/**
- * Infer the most appropriate value property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for value assignment
- */
-export function inferValueProperty(element) {
-    const tagName = element.localName;
-    // Input elements - check type attribute
-    if (tagName === 'input') {
-        const type = element.getAttribute('type')?.toLowerCase();
-        if (type === 'checkbox' || type === 'radio') {
-            return 'checked';
-        }
-        return 'value';
-    }
-    // Form controls with value property
-    if (tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    // Semantic HTML elements with specific properties
-    if (tagName === 'time') {
-        return 'dateTime';
-    }
-    if (tagName === 'data') {
-        return 'value';
-    }
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'value';
-    }
-    if (tagName === 'output') {
-        return 'value';
-    }
-    // Check for itemprop attribute as a hint
-    const itemprop = element.getAttribute('itemprop');
-    if (itemprop) {
-        return itemprop;
-    }
-    // Default fallback
-    return 'textContent';
-}
-/**
- * Infer the most appropriate display property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for display assignment
- */
-export function inferDisplayProperty(element) {
-    const tagName = element.localName;
-    // Form controls display their value
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    // Time elements display formatted time
-    if (tagName === 'time') {
-        return 'textContent';
-    }
-    // Data elements display human-readable content
-    if (tagName === 'data') {
-        return 'textContent';
-    }
-    // Progress/meter elements use ARIA for display
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'ariaValueText';
-    }
-    // Default fallback
-    return 'textContent';
-}
-/**
- * Infer the most appropriate event type for an element
- * Used when no explicit event type is provided
- * @param element - The element to infer the event type for
- * @returns The event type name like 'input', 'change', 'click', 'submit'
- */
-export function inferEventType(element) {
-    const tagName = element.localName;
-    // Form controls that support input event
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'input';
-    }
-    // Form submission
-    if (tagName === 'form') {
-        return 'submit';
-    }
-    // Details element
-    if (tagName === 'details') {
-        return 'toggle';
-    }
-    // Dialog element
-    if (tagName === 'dialog') {
-        return 'close';
-    }
-    // Default fallback for interactive elements
-    return 'click';
-}
-export default registryItem;

package/Infer.ts

@@ -1,190 +0,0 @@
-import type { EnhancementConfig } from "./types/assign-gingerly/types";
-
-/**
- * Symbol for smart value assignment
- * When used with element.set[value], it infers and sets the appropriate value property
- */
-export const value = Symbol.for('assign-gingerly:value');
-
-/**
- * Symbol for smart display assignment
- * When used with element.set[display], it infers and sets the appropriate display property
- */
-export const display = Symbol.for('assign-gingerly:display');
-
-/**
- * Enhancement class that provides smart value and display property inference
- * Automatically determines the correct property to set based on element type
- */
-export class Infer<TValue = any, TDisplay = any> {
-    #weakRef: WeakRef<Element>;
-
-    get enhancedElement(){
-        return this.#weakRef.deref()!;
-    }
-    
-    constructor(enhancedElement?: Element){
-        this.#weakRef = new WeakRef(enhancedElement!);
-    }
-
-    #value: TValue | undefined;
-    
-    get value(): TValue | undefined {
-        return this.#value;
-    }
-    
-    set value(nv: TValue){
-        this.#value = nv;
-        const {enhancedElement} = this;
-        (enhancedElement as any)[inferValueProperty(enhancedElement)] = nv;
-    }
-
-    #display: TDisplay | undefined;
-    
-    get display(): TDisplay | undefined {
-        return this.#display;
-    }
-    
-    set display(nv: TDisplay){
-        this.#display = nv;
-        const {enhancedElement} = this;
-        (enhancedElement as any)[inferDisplayProperty(enhancedElement)] = nv;
-    }
-
-    /**
-     * Get the inferred event type for the element
-     * @returns The most appropriate event type for this element
-     */
-    get eventType(): string {
-        return inferEventType(this.enhancedElement);
-    }
-}
-
-/**
- * Registry item for the Infer enhancement
- * Register this with customElements.enhancementRegistry to enable smart value/display assignment
- */
-export const registryItem: EnhancementConfig = {
-    spawn: Infer,
-    enhKey: 'infer',
-    symlinks: {
-        [value]: 'value',
-        [display]: 'display'
-    }
-}
-
-/**
- * Infer the most appropriate value property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for value assignment
- */
-export function inferValueProperty(element: Element): string {
-    const tagName = element.localName;
-    
-    // Input elements - check type attribute
-    if (tagName === 'input') {
-        const type = element.getAttribute('type')?.toLowerCase();
-        if (type === 'checkbox' || type === 'radio') {
-            return 'checked';
-        }
-        return 'value';
-    }
-    
-    // Form controls with value property
-    if (tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    
-    // Semantic HTML elements with specific properties
-    if (tagName === 'time') {
-        return 'dateTime';
-    }
-    
-    if (tagName === 'data') {
-        return 'value';
-    }
-    
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'value';
-    }
-    
-    if (tagName === 'output') {
-        return 'value';
-    }
-    
-    // Check for itemprop attribute as a hint
-    const itemprop = element.getAttribute('itemprop');
-    if (itemprop) {
-        return itemprop;
-    }
-    
-    // Default fallback
-    return 'textContent';
-}
-
-/**
- * Infer the most appropriate display property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for display assignment
- */
-export function inferDisplayProperty(element: Element): string {
-    const tagName = element.localName;
-    
-    // Form controls display their value
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    
-    // Time elements display formatted time
-    if (tagName === 'time') {
-        return 'textContent';
-    }
-    
-    // Data elements display human-readable content
-    if (tagName === 'data') {
-        return 'textContent';
-    }
-    
-    // Progress/meter elements use ARIA for display
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'ariaValueText';
-    }
-    
-    // Default fallback
-    return 'textContent';
-}
-
-/**
- * Infer the most appropriate event type for an element
- * Used when no explicit event type is provided
- * @param element - The element to infer the event type for
- * @returns The event type name like 'input', 'change', 'click', 'submit'
- */
-export function inferEventType(element: Element): string {
-    const tagName = element.localName;
-    
-    // Form controls that support input event
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'input';
-    }
-    
-    // Form submission
-    if (tagName === 'form') {
-        return 'submit';
-    }
-    
-    // Details element
-    if (tagName === 'details') {
-        return 'toggle';
-    }
-    
-    // Dialog element
-    if (tagName === 'dialog') {
-        return 'close';
-    }
-    
-    // Default fallback for interactive elements
-    return 'click';
-}
-
-export default registryItem;