@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/src/runtime/semantic-role-manager.ts

@@ -1,140 +0,0 @@
-/**
- * Semantic Role Manager - Automatic ARIA Role Application
- * 
- * Manages automatic application of ARIA roles for semantic HTML tags
- * while respecting explicit developer choices and context sensitivity.
- */
-
-import { 
-  SEMANTIC_TAG_ROLES, 
-  getElementOverrideConfig,
-  type SemanticRoleInfo
-} from './element-override'
-import { DevelopmentWarnings } from './development-warnings'
-
-export class SemanticRoleManager {
-  private static instance: SemanticRoleManager
-
-  static getInstance(): SemanticRoleManager {
-    if (!SemanticRoleManager.instance) {
-      SemanticRoleManager.instance = new SemanticRoleManager()
-    }
-    return SemanticRoleManager.instance
-  }
-
-  /**
-   * Apply semantic ARIA attributes to an element based on its tag
-   */
-  applySemanticAttributes(
-    element: HTMLElement, 
-    tag: string, 
-    existingAria?: Record<string, string>
-  ): void {
-    const config = getElementOverrideConfig()
-    
-    // Global config: can disable all automatic ARIA role application
-    if (!config.autoApplySemanticRoles) return
-
-    const semanticInfo = SEMANTIC_TAG_ROLES.get(tag)
-    
-    // Per-tag config: only apply if applyARIA is true for this specific tag
-    if (!semanticInfo || !semanticInfo.applyARIA) return
-
-    // Always respect explicit ARIA attributes from .aria() modifier
-    if (existingAria?.role) {
-      if (config.warnOnSemanticIssues) {
-        DevelopmentWarnings.warnProblematicCombination(
-          'SemanticRole', 
-          tag, 
-          `ARIA role '${existingAria.role}' overrides semantic role '${semanticInfo.role}'`, 
-          'info'
-        )
-      }
-      return
-    }
-
-    // Don't override existing role attribute
-    if (element.hasAttribute('role')) {
-      if (config.warnOnSemanticIssues) {
-        DevelopmentWarnings.warnProblematicCombination(
-          'SemanticRole', 
-          tag, 
-          `Existing role attribute overrides semantic role '${semanticInfo.role}'`, 
-          'info'
-        )
-      }
-      return
-    }
-
-    // Safe to auto-apply the semantic role
-    element.setAttribute('role', semanticInfo.role)
-    
-    if (config.warnOnSemanticIssues) {
-      DevelopmentWarnings.infoSemanticRole(tag, semanticInfo.role)
-    }
-  }
-
-  /**
-   * Get semantic role information for a tag
-   */
-  getSemanticRole(tag: string): SemanticRoleInfo | undefined {
-    return SEMANTIC_TAG_ROLES.get(tag)
-  }
-
-  /**
-   * Check if a tag has automatic ARIA role application enabled
-   */
-  hasAutoARIA(tag: string): boolean {
-    const semanticInfo = SEMANTIC_TAG_ROLES.get(tag)
-    return semanticInfo ? semanticInfo.applyARIA : false
-  }
-
-  /**
-   * Get all tags that support automatic ARIA roles
-   */
-  getAutoARIATags(): string[] {
-    return Array.from(SEMANTIC_TAG_ROLES.entries())
-      .filter(([, info]) => info.applyARIA)
-      .map(([tag]) => tag)
-  }
-
-  /**
-   * Apply semantic attributes during DOM node creation
-   * This is called by the renderer when creating elements
-   */
-  processElementNode(
-    element: HTMLElement,
-    tag: string,
-    componentMetadata?: any,
-    existingAria?: Record<string, string>
-  ): void {
-    // Apply semantic roles
-    this.applySemanticAttributes(element, tag, existingAria)
-
-    // Store metadata for debugging
-    if (componentMetadata && process.env.NODE_ENV !== 'production') {
-      const semanticInfo = this.getSemanticRole(tag)
-      if (semanticInfo) {
-        element.setAttribute('data-tachui-semantic', JSON.stringify({
-          originalComponent: componentMetadata.originalType,
-          overriddenTo: tag,
-          semanticRole: semanticInfo.role,
-          autoApplied: semanticInfo.applyARIA
-        }))
-      }
-    }
-  }
-}
-
-// Global instance
-export const semanticRoleManager = SemanticRoleManager.getInstance()
-
-// Convenience functions
-export const applySemanticAttributes = (
-  element: HTMLElement, 
-  tag: string, 
-  existingAria?: Record<string, string>
-) => semanticRoleManager.applySemanticAttributes(element, tag, existingAria)
-
-export const getSemanticRole = (tag: string) => semanticRoleManager.getSemanticRole(tag)
-export const hasAutoARIA = (tag: string) => semanticRoleManager.hasAutoARIA(tag)

package/src/runtime/types.ts

@@ -1,282 +0,0 @@
-/**
- * Runtime System Type Definitions
- *
- * Core types for the TachUI runtime system including component
- * lifecycle, DOM manipulation, and performance monitoring.
- */
-
-// Core runtime type definitions - no reactive imports needed for types
-
-/**
- * Core component definition
- */
-export interface Component<P = {}> {
-  (props: P): ComponentInstance
-  displayName?: string
-  defaultProps?: Partial<P>
-}
-
-/**
- * Component props with children support
- */
-export interface ComponentProps {
-  children?: ComponentChildren
-  key?: string | number
-  ref?: ComponentRef
-  debugLabel?: string // For debugging - shows component labels in debug mode
-  [key: string]: any
-}
-
-/**
- * Strict component props for type safety
- */
-export interface StrictComponentProps {
-  children?: ComponentChildren
-  key?: string | number
-  ref?: ComponentRef
-}
-
-/**
- * Props validation function
- */
-export type PropsValidator<P> = (props: P) => boolean | string
-
-/**
- * Props with validation
- */
-export interface ValidatedProps<P extends ComponentProps> {
-  validator?: PropsValidator<P>
-  required?: (keyof P)[]
-  defaults?: Partial<P> | undefined
-}
-
-/**
- * Supported children types
- */
-export type ComponentChildren =
-  | string
-  | number
-  | boolean
-  | ComponentInstance
-  | ComponentChildren[]
-  | RenderFunction
-  | null
-  | undefined
-
-/**
- * Children render function
- */
-export type ChildrenRenderer = (children: ComponentChildren) => DOMNode[]
-
-/**
- * Fragment component for multiple children
- */
-export interface Fragment {
-  children: ComponentChildren[]
-}
-
-/**
- * Component instance returned by component functions
- */
-export interface ComponentInstance<P extends ComponentProps = ComponentProps> {
-  type: 'component'
-  render: RenderFunction
-  props: P
-  prevProps?: P
-  children?: ComponentChildren
-  context?: ComponentContext
-  cleanup?: LifecycleCleanup[]
-  id: string
-  ref?: Ref | undefined
-  mounted?: boolean
-  
-  // ENHANCED: Multiple DOM element support
-  domElements?: Map<string, Element>     // Support components with multiple elements
-  primaryElement?: Element               // Main element for simple cases
-  
-  // NEW: DOM readiness tracking
-  domReady?: boolean
-}
-
-/**
- * Render function that creates DOM nodes
- */
-export type RenderFunction = () => DOMNode | DOMNode[]
-
-/**
- * DOM node representation
- */
-export interface DOMNode {
-  type: 'element' | 'text' | 'comment'
-  tag?: string
-  props?: Record<string, any>
-  children?: DOMNode[]
-  text?: string
-  element?: Element | Text | Comment | undefined
-  dispose?: (() => void) | undefined
-}
-
-/**
- * Component context for dependency injection
- */
-export interface ComponentContext {
-  id: string
-  parent?: ComponentContext
-  providers: Map<symbol, any>
-  consumers: Set<symbol>
-  cleanup: Set<() => void>
-
-  // State management methods
-  setState(propertyName: string, value: any): void
-  getState(propertyName: string): any
-  hasState(propertyName: string): boolean
-  setBinding(propertyName: string, binding: any): void
-  getBinding(propertyName: string): any
-
-  // Dependency injection methods
-  provide<T>(symbol: symbol, value: T): void
-  consume<T>(symbol: symbol): T | undefined
-
-  // Lifecycle methods
-  onCleanup(fn: () => void): void
-  dispose(): void
-}
-
-/**
- * Component lifecycle hooks
- */
-export interface LifecycleHooks<P extends ComponentProps = ComponentProps> {
-  onMount?: () => undefined | (() => void)
-  onUpdate?: (prevProps: P, nextProps: P) => void
-  onPropsChange?: (prevProps: P, nextProps: P, changedKeys: (keyof P)[]) => void
-  onChildrenChange?: (prevChildren: ComponentChildren, nextChildren: ComponentChildren) => void
-  onUnmount?: () => void
-  onError?: (error: Error) => void
-  shouldUpdate?: (prevProps: P, nextProps: P) => boolean
-  onRender?: () => void
-  
-  // ENHANCED: DOM-aware lifecycle hooks (Phase 1)
-  onDOMReady?: (elements: Map<string, Element>, primary?: Element) => void | (() => void)
-  onDOMError?: (error: DOMError, context: string) => void
-}
-
-/**
- * DOM Error type for enhanced error handling
- */
-export interface DOMError extends Error {
-  code?: string
-  element?: Element
-  context?: string
-}
-
-
-/**
- * Cleanup function type
- */
-export type LifecycleCleanup = () => void
-
-/**
- * Component reference
- */
-export interface ComponentRef<T = any> {
-  current: T | null
-}
-
-/**
- * Ref callback function
- */
-export type RefCallback<T = any> = (ref: T | null) => void
-
-/**
- * Ref types union
- */
-export type Ref<T = any> = ComponentRef<T> | RefCallback<T> | null
-
-/**
- * Performance metrics
- */
-export interface PerformanceMetrics {
-  componentId: string
-  mountTime: number
-  renderTime: number
-  updateCount: number
-  lastUpdate: number
-  memoryUsage: number
-}
-
-/**
- * Context provider value
- */
-export interface ContextProvider<T> {
-  symbol: symbol
-  value: T
-  subscribers: Set<ComponentContext>
-}
-
-/**
- * Dependency injection service registration
- */
-export interface ServiceRegistration<T = any> {
-  key: symbol | string
-  implementation: T | (() => T)
-  singleton?: boolean
-  scoped?: boolean
-  dependencies?: (symbol | string)[]
-}
-
-/**
- * DI container interface
- */
-export interface IDIContainer {
-  register<T>(
-    key: symbol | string,
-    implementation: T | (() => T),
-    options?: {
-      singleton?: boolean
-      scoped?: boolean
-      dependencies?: (symbol | string)[]
-    }
-  ): void
-  resolve<T>(key: symbol | string): T
-  has(key: symbol | string): boolean
-  clear(): void
-}
-
-/**
- * Context subscription info
- */
-export interface ContextSubscription {
-  contextSymbol: symbol
-  componentId: string
-  unsubscribe: () => void
-}
-
-/**
- * Mount options
- */
-export interface MountOptions {
-  container: Element
-  hydrate?: boolean
-  onError?: (error: Error) => void
-  enablePerformanceTracking?: boolean
-}
-
-/**
- * Update options
- */
-export interface UpdateOptions {
-  force?: boolean
-  suppressEffects?: boolean
-}
-
-/**
- * Component tree node for development tools
- */
-export interface ComponentTreeNode {
-  id: string
-  name: string
-  props: ComponentProps
-  children: ComponentTreeNode[]
-  metrics: PerformanceMetrics
-  context: string[]
-}