mtrl 0.2.6 → 0.2.8

package/src/components/slider/features/keyboard.ts

@@ -1,233 +0,0 @@
-// src/components/slider/features/keyboard.ts
-import { SLIDER_EVENTS } from '../constants';
-
-/**
- * Add keyboard interaction handlers to slider component
- * 
- * @param state Slider state object
- * @param handlers Object containing handler methods
- * @returns Event handlers for keyboard interactions
- */
-export const createKeyboardHandlers = (state, handlers) => {
-  const {
-    secondThumb,
-    secondValueBubble,
-    valueBubble
-  } = state.component.structure;
-  
-  const {
-    showValueBubble,
-    updateUi,
-    triggerEvent
-  } = handlers;
-  
-  // Last focused thumb tracker to handle tab sequences properly
-  let lastFocusedThumb = null;
-  
-  /**
-   * Clear any existing bubble hide timers
-   */
-  const clearBubbleHideTimer = () => {
-    if (state.valueHideTimer) {
-      clearTimeout(state.valueHideTimer);
-      state.valueHideTimer = null;
-    }
-  };
-  
-  /**
-   * Hide all bubbles immediately
-   */
-  const hideAllBubbles = () => {
-    // Clear any pending hide timers
-    clearBubbleHideTimer();
-    
-    // Hide both bubbles immediately
-    if (valueBubble) {
-      showValueBubble(valueBubble, false);
-    }
-    if (secondValueBubble) {
-      showValueBubble(secondValueBubble, false);
-    }
-  };
-  
-  /**
-   * Shows a bubble element with consistent behavior
-   */
-  const showBubble = (bubble) => {
-    // First hide all bubbles
-    hideAllBubbles();
-    
-    // Then show the active bubble
-    if (bubble) {
-      showValueBubble(bubble, true);
-    }
-  };
-  
-  /**
-   * Hides a bubble element with optional delay
-   */
-  const hideBubble = (bubble, delay = 0) => {
-    // Clear any existing timers
-    clearBubbleHideTimer();
-    
-    if (!bubble) return;
-    
-    if (delay > 0) {
-      state.valueHideTimer = setTimeout(() => {
-        showValueBubble(bubble, false);
-      }, delay);
-    } else {
-      showValueBubble(bubble, false);
-    }
-  };
-  
-  // Event handlers
-  const handleKeyDown = (e, isSecondThumb = false) => {
-    if (state.component.disabled && state.component.disabled.isDisabled()) return;
-    
-    const step = state.step || 1;
-    let newValue;
-    let stepSize = step;
-    
-    // Determine which value to modify
-    if (isSecondThumb) {
-      newValue = state.secondValue;
-    } else {
-      newValue = state.value;
-    }
-    
-    // Handle tab key specifically for range sliders
-    if (e.key === 'Tab') {
-      // Let the browser handle the tab navigation
-      // We'll deal with showing/hiding bubbles in the focus/blur handlers
-      return;
-    }
-    
-    // Determine step size based on modifier keys
-    if (e.shiftKey) {
-      stepSize = step * 10; // Large step when Shift is pressed
-    }
-    
-    let valueChanged = false;
-    
-    switch (e.key) {
-      case 'ArrowRight':
-      case 'ArrowUp':
-        e.preventDefault();
-        newValue = Math.min(newValue + stepSize, state.max);
-        valueChanged = true;
-        break;
-        
-      case 'ArrowLeft':
-      case 'ArrowDown':
-        e.preventDefault();
-        newValue = Math.max(newValue - stepSize, state.min);
-        valueChanged = true;
-        break;
-        
-      case 'Home':
-        e.preventDefault();
-        newValue = state.min;
-        valueChanged = true;
-        break;
-        
-      case 'End':
-        e.preventDefault();
-        newValue = state.max;
-        valueChanged = true;
-        break;
-        
-      case 'PageUp':
-        e.preventDefault();
-        newValue = Math.min(newValue + (step * 10), state.max);
-        valueChanged = true;
-        break;
-        
-      case 'PageDown':
-        e.preventDefault();
-        newValue = Math.max(newValue - (step * 10), state.min);
-        valueChanged = true;
-        break;
-        
-      default:
-        return; // Exit if not a handled key
-    }
-    
-    if (!valueChanged) return;
-    
-    // Update active bubble reference
-    state.activeBubble = isSecondThumb ? secondValueBubble : valueBubble;
-    
-    // Show value bubble during keyboard interaction
-    showBubble(state.activeBubble);
-    
-    // Update the value
-    if (isSecondThumb) {
-      state.secondValue = newValue;
-    } else {
-      state.value = newValue;
-    }
-    
-    // Update UI
-    updateUi();
-    
-    // Trigger events
-    triggerEvent(SLIDER_EVENTS.INPUT, e);
-    triggerEvent(SLIDER_EVENTS.CHANGE, e);
-  };
-  
-  const handleFocus = (e, isSecondThumb = false) => {
-    if (state.component.disabled && state.component.disabled.isDisabled()) return;
-    
-    // Track the currently focused thumb for tab sequence handling
-    const currentThumb = isSecondThumb ? secondThumb : state.component.structure.thumb;
-    
-    // If we're tabbing between thumbs, hide the previous bubble immediately
-    if (lastFocusedThumb && lastFocusedThumb !== currentThumb) {
-      hideAllBubbles();
-    }
-    
-    // Update the last focused thumb
-    lastFocusedThumb = currentThumb;
-    
-    // Add a class to indicate keyboard focus
-    currentThumb.classList.add(`${state.component.getClass('slider-thumb')}--focused`);
-    
-    // Show value bubble on focus
-    const bubble = isSecondThumb ? secondValueBubble : valueBubble;
-    showBubble(bubble);
-    
-    // Update active bubble reference
-    state.activeBubble = bubble;
-    
-    // Trigger focus event
-    triggerEvent(SLIDER_EVENTS.FOCUS, e);
-  };
-  
-  const handleBlur = (e, isSecondThumb = false) => {
-    // Remove keyboard focus class
-    const thumb = isSecondThumb ? secondThumb : state.component.structure.thumb;
-    thumb.classList.remove(`${state.component.getClass('slider-thumb')}--focused`);
-    
-    // Only hide the bubble if we're not tabbing to another thumb
-    // This check prevents the bubble from flickering when tabbing between thumbs
-    const relatedTarget = e.relatedTarget;
-    const otherThumb = isSecondThumb ? state.component.structure.thumb : secondThumb;
-    
-    if (!relatedTarget || relatedTarget !== otherThumb) {
-      // We're not tabbing to the other thumb, so we can hide the bubble
-      const bubble = isSecondThumb ? secondValueBubble : valueBubble;
-      hideBubble(bubble, 200);
-    }
-    
-    // Trigger blur event
-    triggerEvent(SLIDER_EVENTS.BLUR, e);
-  };
-  
-  // Return handlers
-  return {
-    handleKeyDown,
-    handleFocus,
-    handleBlur
-  };
-};

package/src/components/switch/constants.ts

@@ -1,80 +0,0 @@
-// src/components/switch/constants.ts
-
-/**
- * Label position options
- */
-export const SWITCH_LABEL_POSITION = {
-  START: 'start',
-  END: 'end'
-} as const;
-
-/**
- * Validation schema for switch configuration
- */
-export const SWITCH_SCHEMA = {
-  type: 'object',
-  properties: {
-    name: {
-      type: 'string',
-      optional: true
-    },
-    checked: {
-      type: 'boolean',
-      optional: true
-    },
-    required: {
-      type: 'boolean',
-      optional: true
-    },
-    disabled: {
-      type: 'boolean',
-      optional: true
-    },
-    value: {
-      type: 'string',
-      optional: true
-    },
-    label: {
-      type: 'string',
-      optional: true
-    },
-    labelPosition: {
-      type: 'string',
-      enum: Object.values(SWITCH_LABEL_POSITION),
-      optional: true
-    },
-    icon: {
-      type: 'string',
-      optional: true
-    },
-    ariaLabel: {
-      type: 'string',
-      optional: true
-    },
-    class: {
-      type: 'string',
-      optional: true
-    }
-  }
-} as const;
-
-/**
- * Switch state classes
- */
-export const SWITCH_STATES = {
-  CHECKED: 'checked',
-  DISABLED: 'disabled',
-  FOCUSED: 'focused'
-} as const;
-
-/**
- * Switch element classes
- */
-export const SWITCH_CLASSES = {
-  ROOT: 'switch',
-  INPUT: 'switch-input',
-  TRACK: 'switch-track',
-  THUMB: 'thumb',
-  THUMB_ICON: 'thumb-icon',
-  LABEL: 'switch-label'
-} as const;

package/src/components/tabs/constants.ts

@@ -1,89 +0,0 @@
-// src/components/tabs/constants.ts
-
-/**
- * Tab variants
- */
-export const TABS_VARIANTS = {
-  /** Primary tabs (standard MD3 style) */
-  PRIMARY: 'primary',
-  /** Secondary tabs (less prominent variant) */
-  SECONDARY: 'secondary'
-};
-
-/**
- * Tab states
- */
-export const TAB_STATES = {
-  /** Active (selected) tab state */
-  ACTIVE: 'active',
-  /** Inactive (unselected) tab state */
-  INACTIVE: 'inactive',
-  /** Disabled tab state */
-  DISABLED: 'disabled'
-};
-
-/**
- * Tab layout types
- */
-export const TAB_LAYOUT = {
-  /** Icon-only tab layout */
-  ICON_ONLY: 'icon-only',
-  /** Text-only tab layout */
-  TEXT_ONLY: 'text-only',
-  /** Icon and text layout */
-  ICON_AND_TEXT: 'icon-and-text'
-};
-
-/**
- * Tab interaction states (for styling)
- */
-export const TAB_INTERACTION_STATES = {
-  /** Default enabled state */
-  ENABLED: 'enabled',
-  /** Hover state */
-  HOVER: 'hover',
-  /** Focus state */
-  FOCUS: 'focus',
-  /** Pressed/active state */
-  PRESSED: 'pressed'
-};
-
-/**
- * Tab animation constants
- */
-export const TAB_ANIMATION = {
-  /** Standard transition duration in ms */
-  TRANSITION_DURATION: 200,
-  /** Standard transition timing function */
-  TRANSITION_TIMING: 'cubic-bezier(0.4, 0, 0.2, 1)',
-  /** Ripple animation duration in ms */
-  RIPPLE_DURATION: 400
-};
-
-/**
- * Tab accessibility roles
- */
-export const TAB_A11Y = {
-  /** Tab role */
-  TAB_ROLE: 'tab',
-  /** Tablist role */
-  TABLIST_ROLE: 'tablist',
-  /** Tabpanel role */
-  TABPANEL_ROLE: 'tabpanel'
-};
-
-/**
- * MD3 tokens for tab colors
- */
-export const TAB_COLORS = {
-  /** Surface color for container */
-  SURFACE: 'surface',
-  /** Primary color for active tab and indicator */
-  PRIMARY: 'primary',
-  /** On-surface color for active secondary tabs */
-  ON_SURFACE: 'on-surface',
-  /** On-surface-variant for inactive tabs */
-  ON_SURFACE_VARIANT: 'on-surface-variant',
-  /** Outline variant for divider */
-  OUTLINE_VARIANT: 'outline-variant'
-};

package/src/core/collection/adapters/mongodb.js

@@ -1,232 +0,0 @@
-// src/core/collection/adapters/mongodb.js
-
-import { MongoClient, ObjectId } from 'mongodb'
-import { OPERATORS, createBaseAdapter } from './base'
-
-const MONGODB_OPERATORS = {
-  [OPERATORS.EQ]: '$eq',
-  [OPERATORS.NE]: '$ne',
-  [OPERATORS.GT]: '$gt',
-  [OPERATORS.GTE]: '$gte',
-  [OPERATORS.LT]: '$lt',
-  [OPERATORS.LTE]: '$lte',
-  [OPERATORS.IN]: '$in',
-  [OPERATORS.NIN]: '$nin',
-  [OPERATORS.CONTAINS]: '$regex',
-  [OPERATORS.STARTS_WITH]: '$regex',
-  [OPERATORS.ENDS_WITH]: '$regex'
-}
-
-export const createMongoAdapter = (config = {}) => {
-  const base = createBaseAdapter(config)
-  let client = null
-  let db = null
-  let collection = null
-
-  const transformDocument = (doc) => {
-    if (!doc) return null
-    const { _id, ...rest } = doc
-    return { id: _id.toString(), ...rest }
-  }
-
-  const transformForMongo = (doc) => {
-    if (!doc) return null
-    const { id, ...rest } = doc
-    return { _id: id ? new ObjectId(id) : new ObjectId(), ...rest }
-  }
-
-  const transformQuery = (query) => {
-    const transformed = {}
-
-    Object.entries(query).forEach(([field, conditions]) => {
-      if (typeof conditions === 'object') {
-        transformed[field] = Object.entries(conditions).reduce((acc, [op, value]) => {
-          const mongoOp = MONGODB_OPERATORS[op]
-          if (!mongoOp) return acc
-
-          if (op === OPERATORS.CONTAINS) {
-            acc[mongoOp] = new RegExp(value, 'i')
-          } else if (op === OPERATORS.STARTS_WITH) {
-            acc[mongoOp] = new RegExp(`^${value}`, 'i')
-          } else if (op === OPERATORS.ENDS_WITH) {
-            acc[mongoOp] = new RegExp(`${value}$`, 'i')
-          } else {
-            acc[mongoOp] = value
-          }
-
-          return acc
-        }, {})
-      } else {
-        transformed[field] = conditions
-      }
-    })
-
-    return transformed
-  }
-
-  return {
-    ...base,
-
-    connect: async () => {
-      try {
-        client = new MongoClient(config.uri, {
-          useUnifiedTopology: true,
-          maxPoolSize: 10,
-          ...config.options
-        })
-
-        await client.connect()
-        db = client.db(config.dbName)
-        collection = db.collection(config.collection)
-
-        // Optional: Create indexes
-        // await collection.createIndex({ field: 1 })
-      } catch (error) {
-        return base.handleError(new Error(`MongoDB connection failed: ${error.message}`))
-      }
-    },
-
-    disconnect: async () => {
-      if (client) {
-        await client.close()
-        client = null
-        db = null
-        collection = null
-      }
-    },
-
-    create: async (items) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const docs = items.map(item => transformForMongo(item))
-      const result = await collection.insertMany(docs)
-
-      return items.map((item, index) => ({
-        ...item,
-        id: result.insertedIds[index].toString()
-      }))
-    },
-
-    read: async (query = {}, options = {}) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const {
-        skip = 0,
-        limit = 0,
-        sort = {},
-        projection = {}
-      } = options
-
-      const mongoQuery = transformQuery(query)
-
-      const cursor = collection
-        .find(mongoQuery)
-        .skip(skip)
-        .limit(limit)
-        .project(projection)
-        .sort(sort)
-
-      const docs = await cursor.toArray()
-      return docs.map(doc => transformDocument(doc))
-    },
-
-    update: async (items) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const operations = items.map(item => ({
-        updateOne: {
-          filter: { _id: new ObjectId(item.id) },
-          update: { $set: transformForMongo(item) },
-          upsert: false
-        }
-      }))
-
-      await collection.bulkWrite(operations)
-      return items
-    },
-
-    delete: async (ids) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const mongoIds = ids.map(id => new ObjectId(id))
-      await collection.deleteMany({ _id: { $in: mongoIds } })
-      return ids
-    },
-
-    query: async (query = {}, options = {}) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const {
-        pipeline = [],
-        skip = 0,
-        limit = 0
-      } = options
-
-      const mongoQuery = transformQuery(query)
-
-      const aggregation = [
-        { $match: mongoQuery },
-        ...pipeline
-      ]
-
-      if (skip > 0) {
-        aggregation.push({ $skip: skip })
-      }
-
-      if (limit > 0) {
-        aggregation.push({ $limit: limit })
-      }
-
-      const docs = await collection.aggregate(aggregation).toArray()
-
-      return {
-        results: docs.map(doc => transformDocument(doc)),
-        total: await collection.countDocuments(mongoQuery)
-      }
-    },
-
-    watch: (callback, pipeline = []) => {
-      if (!collection) {
-        return base.handleError(new Error('Not connected to MongoDB'))
-      }
-
-      const changeStream = collection.watch(pipeline, {
-        fullDocument: 'updateLookup'
-      })
-
-      changeStream.on('change', async (change) => {
-        const { operationType, documentKey, fullDocument } = change
-
-        switch (operationType) {
-          case 'insert':
-          case 'update':
-          case 'replace':
-            callback({
-              type: operationType,
-              document: transformDocument(fullDocument)
-            })
-            break
-
-          case 'delete':
-            callback({
-              type: operationType,
-              documentId: documentKey._id.toString()
-            })
-            break
-        }
-      })
-
-      return () => changeStream.close()
-    }
-  }
-}