@object-ui/core 3.3.0 → 3.3.2

package/src/__tests__/protocols/DndProtocol.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { DndConfig, DragItem, DropZone, DragConstraint } from '@object-ui/types';
-import {
-  resolveDndConfig,
-  createDragItemProps,
-  createDropZoneProps,
-  resolveDragConstraints,
-} from '../../protocols/DndProtocol';
-
-describe('DndProtocol', () => {
-  // ==========================================================================
-  // resolveDndConfig
-  // ==========================================================================
-  describe('resolveDndConfig', () => {
-    it('should apply all defaults for minimal config', () => {
-      const config = {} as DndConfig;
-      const resolved = resolveDndConfig(config);
-
-      expect(resolved.enabled).toBe(false);
-      expect(resolved.sortable).toBe(false);
-      expect(resolved.autoScroll).toBe(true);
-      expect(resolved.touchDelay).toBe(200);
-      expect(resolved.dragItem).toBeUndefined();
-      expect(resolved.dropZone).toBeUndefined();
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        enabled: true,
-        sortable: true,
-        autoScroll: false,
-        touchDelay: 500,
-      } as DndConfig;
-      const resolved = resolveDndConfig(config);
-
-      expect(resolved.enabled).toBe(true);
-      expect(resolved.sortable).toBe(true);
-      expect(resolved.autoScroll).toBe(false);
-      expect(resolved.touchDelay).toBe(500);
-    });
-
-    it('should pass through dragItem and dropZone', () => {
-      const dragItem = { type: 'card' } as DragItem;
-      const dropZone = { accept: ['card'] } as DropZone;
-      const config = { dragItem, dropZone } as DndConfig;
-      const resolved = resolveDndConfig(config);
-
-      expect(resolved.dragItem).toBe(dragItem);
-      expect(resolved.dropZone).toBe(dropZone);
-    });
-  });
-
-  // ==========================================================================
-  // createDragItemProps
-  // ==========================================================================
-  describe('createDragItemProps', () => {
-    it('should return correct props for a basic drag item', () => {
-      const item = { type: 'card', label: 'Task card' } as DragItem;
-      const props = createDragItemProps(item);
-
-      expect(props.draggable).toBe(true);
-      expect(props['aria-roledescription']).toBe('draggable');
-      expect(props['aria-label']).toBe('Task card');
-      expect(props.role).toBe('listitem');
-      expect(props['data-drag-type']).toBe('card');
-      expect(props['data-drag-handle']).toBe('element');
-      expect(props['data-drag-disabled']).toBe('false');
-    });
-
-    it('should set draggable false when disabled', () => {
-      const item = { type: 'card', disabled: true } as DragItem;
-      const props = createDragItemProps(item);
-
-      expect(props.draggable).toBe(false);
-      expect(props['data-drag-disabled']).toBe('true');
-    });
-
-    it('should use ariaLabel over label when both provided', () => {
-      const item = { type: 'card', label: 'Label', ariaLabel: 'Aria Label' } as DragItem;
-      const props = createDragItemProps(item);
-
-      expect(props['aria-label']).toBe('Aria Label');
-    });
-
-    it('should use ariaLabel when provided as string', () => {
-      const item = {
-        type: 'card',
-        ariaLabel: 'Translated label',
-      } as unknown as DragItem;
-      const props = createDragItemProps(item);
-
-      expect(props['aria-label']).toBe('Translated label');
-    });
-
-    it('should use custom role and handle when provided', () => {
-      const item = { type: 'row', role: 'option', handle: 'grip' } as DragItem;
-      const props = createDragItemProps(item);
-
-      expect(props.role).toBe('option');
-      expect(props['data-drag-handle']).toBe('grip');
-    });
-  });
-
-  // ==========================================================================
-  // createDropZoneProps
-  // ==========================================================================
-  describe('createDropZoneProps', () => {
-    it('should return correct props for a basic drop zone', () => {
-      const zone = { accept: ['card', 'task'], label: 'Column' } as unknown as DropZone;
-      const props = createDropZoneProps(zone);
-
-      expect(props['aria-dropeffect']).toBe('move');
-      expect(props['aria-label']).toBe('Column');
-      expect(props.role).toBe('list');
-      expect(props['data-drop-accept']).toBe('card,task');
-      expect(props['data-drop-highlight']).toBe('true');
-    });
-
-    it('should use explicit dropEffect and role', () => {
-      const zone = { accept: ['item'], dropEffect: 'copy', role: 'region' } as unknown as DropZone;
-      const props = createDropZoneProps(zone);
-
-      expect(props['aria-dropeffect']).toBe('copy');
-      expect(props.role).toBe('region');
-    });
-
-    it('should set maxItems when provided', () => {
-      const zone = { accept: ['card'], maxItems: 10 } as unknown as DropZone;
-      const props = createDropZoneProps(zone);
-
-      expect(props['data-drop-max-items']).toBe(10);
-    });
-
-    it('should use ariaLabel string when provided', () => {
-      const zone = {
-        accept: ['card'],
-        ariaLabel: 'Drop here',
-      } as unknown as DropZone;
-      const props = createDropZoneProps(zone);
-
-      expect(props['aria-label']).toBe('Drop here');
-    });
-  });
-
-  // ==========================================================================
-  // resolveDragConstraints
-  // ==========================================================================
-  describe('resolveDragConstraints', () => {
-    it('should return base styles for default axis (both)', () => {
-      const constraint = {} as DragConstraint;
-      const styles = resolveDragConstraints(constraint);
-
-      expect(styles.position).toBe('relative');
-      expect(styles.touchAction).toBe('none');
-    });
-
-    it('should set touchAction to pan-y for x axis', () => {
-      const constraint = { axis: 'x' } as DragConstraint;
-      const styles = resolveDragConstraints(constraint);
-
-      expect(styles.touchAction).toBe('pan-y');
-    });
-
-    it('should set touchAction to pan-x for y axis', () => {
-      const constraint = { axis: 'y' } as DragConstraint;
-      const styles = resolveDragConstraints(constraint);
-
-      expect(styles.touchAction).toBe('pan-x');
-    });
-
-    it('should set overflow hidden for parent bounds', () => {
-      const constraint = { bounds: 'parent' } as DragConstraint;
-      const styles = resolveDragConstraints(constraint);
-
-      expect(styles.overflow).toBe('hidden');
-    });
-
-    it('should set grid CSS custom properties', () => {
-      const constraint = { grid: [20, 30] } as unknown as DragConstraint;
-      const styles = resolveDragConstraints(constraint);
-
-      expect(styles['--drag-grid-x']).toBe('20px');
-      expect(styles['--drag-grid-y']).toBe('30px');
-    });
-  });
-});

package/src/__tests__/protocols/KeyboardProtocol.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { KeyboardNavigationConfig, FocusTrapConfig } from '@object-ui/types';
-import {
-  resolveKeyboardConfig,
-  parseShortcutKey,
-  matchesShortcut,
-  createFocusTrapConfig,
-} from '../../protocols/KeyboardProtocol';
-
-describe('KeyboardProtocol', () => {
-  // ==========================================================================
-  // resolveKeyboardConfig
-  // ==========================================================================
-  describe('resolveKeyboardConfig', () => {
-    it('should apply defaults for empty config', () => {
-      const config = {} as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.shortcuts).toEqual([]);
-      expect(resolved.rovingTabindex).toBe(false);
-      expect(resolved.focusManagement.tabOrder).toBe('auto');
-      expect(resolved.focusManagement.skipLinks).toBe(false);
-      expect(resolved.focusManagement.focusVisible).toBe(true);
-      expect(resolved.focusManagement.arrowNavigation).toBe(false);
-      expect(resolved.focusManagement.focusTrap).toBeUndefined();
-    });
-
-    it('should resolve ariaLabel from string', () => {
-      const config = { ariaLabel: 'Navigation' } as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.ariaLabel).toBe('Navigation');
-    });
-
-    it('should resolve ariaLabel from string', () => {
-      const config = {
-        ariaLabel: 'Nav panel',
-      } as unknown as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.ariaLabel).toBe('Nav panel');
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        rovingTabindex: true,
-        role: 'toolbar',
-        ariaDescribedBy: 'desc-id',
-      } as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.rovingTabindex).toBe(true);
-      expect(resolved.role).toBe('toolbar');
-      expect(resolved.ariaDescribedBy).toBe('desc-id');
-    });
-  });
-
-  // ==========================================================================
-  // parseShortcutKey
-  // ==========================================================================
-  describe('parseShortcutKey', () => {
-    it('should parse Ctrl+S', () => {
-      const parsed = parseShortcutKey('Ctrl+S');
-
-      expect(parsed.key).toBe('s');
-      expect(parsed.ctrlOrMeta).toBe(true);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should parse Alt+Shift+N', () => {
-      const parsed = parseShortcutKey('Alt+Shift+N');
-
-      expect(parsed.key).toBe('n');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(true);
-      expect(parsed.alt).toBe(true);
-    });
-
-    it('should parse single key Escape', () => {
-      const parsed = parseShortcutKey('Escape');
-
-      expect(parsed.key).toBe('escape');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should be case insensitive', () => {
-      const parsed = parseShortcutKey('ctrl+s');
-
-      expect(parsed.key).toBe('s');
-      expect(parsed.ctrlOrMeta).toBe(true);
-    });
-
-    it('should parse single key F1', () => {
-      const parsed = parseShortcutKey('F1');
-
-      expect(parsed.key).toBe('f1');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should recognise Meta as ctrlOrMeta', () => {
-      const parsed = parseShortcutKey('Meta+K');
-
-      expect(parsed.ctrlOrMeta).toBe(true);
-      expect(parsed.key).toBe('k');
-    });
-  });
-
-  // ==========================================================================
-  // matchesShortcut
-  // ==========================================================================
-  describe('matchesShortcut', () => {
-    it('should match Ctrl+S event', () => {
-      const event = { key: 's', ctrlKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(true);
-    });
-
-    it('should match Meta+S event (Cmd on Mac)', () => {
-      const event = { key: 's', metaKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(true);
-    });
-
-    it('should not match when key differs', () => {
-      const event = { key: 'a', ctrlKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should not match when modifier is missing', () => {
-      const event = { key: 's' };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should not match when extra modifier is present', () => {
-      const event = { key: 's', ctrlKey: true, shiftKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should match Escape without modifiers', () => {
-      const event = { key: 'Escape' };
-      expect(matchesShortcut(event, 'Escape')).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // createFocusTrapConfig
-  // ==========================================================================
-  describe('createFocusTrapConfig', () => {
-    it('should apply defaults for minimal config', () => {
-      const config = {} as FocusTrapConfig;
-      const resolved = createFocusTrapConfig(config);
-
-      expect(resolved.enabled).toBe(false);
-      expect(resolved.returnFocus).toBe(true);
-      expect(resolved.escapeDeactivates).toBe(true);
-      expect(resolved.initialFocus).toBeUndefined();
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        enabled: true,
-        initialFocus: '#first-input',
-        returnFocus: false,
-        escapeDeactivates: false,
-      } as FocusTrapConfig;
-      const resolved = createFocusTrapConfig(config);
-
-      expect(resolved.enabled).toBe(true);
-      expect(resolved.initialFocus).toBe('#first-input');
-      expect(resolved.returnFocus).toBe(false);
-      expect(resolved.escapeDeactivates).toBe(false);
-    });
-  });
-});

package/src/__tests__/protocols/NotificationProtocol.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type {
-  Notification as SpecNotification,
-  NotificationConfig,
-} from '@object-ui/types';
-import {
-  specNotificationToToast,
-  mapSeverityToVariant,
-  mapPosition,
-  resolveNotificationConfig,
-} from '../../protocols/NotificationProtocol';
-
-describe('NotificationProtocol', () => {
-  // ==========================================================================
-  // mapSeverityToVariant
-  // ==========================================================================
-  describe('mapSeverityToVariant', () => {
-    it.each([
-      ['info', 'default'],
-      ['success', 'success'],
-      ['warning', 'warning'],
-      ['error', 'destructive'],
-    ] as const)('should map "%s" to "%s"', (severity, expected) => {
-      expect(mapSeverityToVariant(severity)).toBe(expected);
-    });
-
-    it('should fall back to "default" for unknown severity', () => {
-      expect(mapSeverityToVariant('critical')).toBe('default');
-    });
-  });
-
-  // ==========================================================================
-  // mapPosition
-  // ==========================================================================
-  describe('mapPosition', () => {
-    it.each([
-      ['top_left', 'top-left'],
-      ['top_center', 'top-center'],
-      ['top_right', 'top-right'],
-      ['bottom_left', 'bottom-left'],
-      ['bottom_center', 'bottom-center'],
-      ['bottom_right', 'bottom-right'],
-    ] as const)('should map "%s" to "%s"', (spec, expected) => {
-      expect(mapPosition(spec)).toBe(expected);
-    });
-
-    it('should fall back to "top-right" for unknown position', () => {
-      expect(mapPosition('center')).toBe('top-right');
-    });
-  });
-
-  // ==========================================================================
-  // resolveNotificationConfig
-  // ==========================================================================
-  describe('resolveNotificationConfig', () => {
-    it('should apply all defaults for empty config', () => {
-      const config = {} as NotificationConfig;
-      const resolved = resolveNotificationConfig(config);
-
-      expect(resolved.defaultPosition).toBe('top_right');
-      expect(resolved.defaultDuration).toBe(5000);
-      expect(resolved.maxVisible).toBe(5);
-      expect(resolved.stackDirection).toBe('down');
-      expect(resolved.pauseOnHover).toBe(true);
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        defaultPosition: 'bottom_left',
-        defaultDuration: 3000,
-        maxVisible: 3,
-        stackDirection: 'up',
-        pauseOnHover: false,
-      } as NotificationConfig;
-      const resolved = resolveNotificationConfig(config);
-
-      expect(resolved.defaultPosition).toBe('bottom_left');
-      expect(resolved.defaultDuration).toBe(3000);
-      expect(resolved.maxVisible).toBe(3);
-      expect(resolved.stackDirection).toBe('up');
-      expect(resolved.pauseOnHover).toBe(false);
-    });
-  });
-
-  // ==========================================================================
-  // specNotificationToToast
-  // ==========================================================================
-  describe('specNotificationToToast', () => {
-    it('should convert a basic notification to toast', () => {
-      const notification = {
-        message: 'Record saved',
-        severity: 'success',
-      } as SpecNotification;
-      const toast = specNotificationToToast(notification);
-
-      expect(toast.description).toBe('Record saved');
-      expect(toast.variant).toBe('success');
-      expect(toast.position).toBe('top-right');
-      expect(toast.duration).toBe(5000);
-      expect(toast.dismissible).toBe(true);
-      expect(toast.actions).toEqual([]);
-    });
-
-    it('should handle string title and message', () => {
-      const notification = {
-        title: 'Heads up',
-        message: 'Something happened',
-      } as unknown as SpecNotification;
-      const toast = specNotificationToToast(notification);
-
-      expect(toast.title).toBe('Heads up');
-      expect(toast.description).toBe('Something happened');
-    });
-
-    it('should map actions to toast actions', () => {
-      const notification = {
-        message: 'Error occurred',
-        severity: 'error',
-        actions: [
-          { label: 'Retry', action: 'retry', variant: 'primary' },
-          { label: 'Dismiss', action: 'dismiss', variant: 'secondary' },
-        ],
-      } as unknown as SpecNotification;
-      const toast = specNotificationToToast(notification);
-
-      expect(toast.actions).toHaveLength(2);
-      expect(toast.actions[0]).toEqual({ label: 'Retry', action: 'retry', variant: 'primary' });
-      expect(toast.actions[1]).toEqual({ label: 'Dismiss', action: 'dismiss', variant: 'secondary' });
-    });
-
-    it('should apply defaults for missing fields', () => {
-      const notification = {} as SpecNotification;
-      const toast = specNotificationToToast(notification);
-
-      expect(toast.description).toBe('');
-      expect(toast.variant).toBe('default');
-      expect(toast.position).toBe('top-right');
-      expect(toast.duration).toBe(5000);
-      expect(toast.dismissible).toBe(true);
-    });
-  });
-});

package/src/__tests__/protocols/ResponsiveProtocol.test.ts

@@ -1,176 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { SpecResponsiveConfig } from '@object-ui/types';
-import {
-  getVisibilityClasses,
-  getColumnClasses,
-  getOrderClasses,
-  shouldHideAtBreakpoint,
-  resolveResponsiveConfig,
-  BREAKPOINT_VALUES,
-} from '../../protocols/ResponsiveProtocol';
-
-describe('ResponsiveProtocol', () => {
-  // ==========================================================================
-  // BREAKPOINT_VALUES
-  // ==========================================================================
-  describe('BREAKPOINT_VALUES', () => {
-    it('should export correct pixel values for all breakpoints', () => {
-      expect(BREAKPOINT_VALUES.xs).toBe(0);
-      expect(BREAKPOINT_VALUES.sm).toBe(640);
-      expect(BREAKPOINT_VALUES.md).toBe(768);
-      expect(BREAKPOINT_VALUES.lg).toBe(1024);
-      expect(BREAKPOINT_VALUES.xl).toBe(1280);
-      expect(BREAKPOINT_VALUES['2xl']).toBe(1536);
-    });
-  });
-
-  // ==========================================================================
-  // resolveResponsiveConfig
-  // ==========================================================================
-  describe('resolveResponsiveConfig', () => {
-    it('should apply defaults for empty config', () => {
-      const config = {} as SpecResponsiveConfig;
-      const resolved = resolveResponsiveConfig(config);
-
-      expect(resolved.breakpoint).toBeUndefined();
-      expect(resolved.hiddenOn).toEqual([]);
-      expect(resolved.columns).toEqual({});
-      expect(resolved.order).toEqual({});
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        breakpoint: 'md',
-        hiddenOn: ['sm'],
-        columns: { xs: 1, md: 2 },
-        order: { xs: 2, md: 1 },
-      } as SpecResponsiveConfig;
-      const resolved = resolveResponsiveConfig(config);
-
-      expect(resolved.breakpoint).toBe('md');
-      expect(resolved.hiddenOn).toEqual(['sm']);
-      expect(resolved.columns).toEqual({ xs: 1, md: 2 });
-      expect(resolved.order).toEqual({ xs: 2, md: 1 });
-    });
-  });
-
-  // ==========================================================================
-  // getVisibilityClasses
-  // ==========================================================================
-  describe('getVisibilityClasses', () => {
-    it('should return empty array for no visibility config', () => {
-      const config = {} as SpecResponsiveConfig;
-      expect(getVisibilityClasses(config)).toEqual([]);
-    });
-
-    it('should return hidden + breakpoint:block for minimum breakpoint', () => {
-      const config = { breakpoint: 'md' } as SpecResponsiveConfig;
-      const classes = getVisibilityClasses(config);
-
-      expect(classes).toContain('hidden');
-      expect(classes).toContain('md:block');
-    });
-
-    it('should not add hidden class for xs breakpoint', () => {
-      const config = { breakpoint: 'xs' } as SpecResponsiveConfig;
-      const classes = getVisibilityClasses(config);
-
-      expect(classes).not.toContain('hidden');
-    });
-
-    it('should generate toggle classes for hiddenOn', () => {
-      const config = { hiddenOn: ['sm'] } as SpecResponsiveConfig;
-      const classes = getVisibilityClasses(config);
-
-      expect(classes).toContain('sm:hidden');
-      expect(classes).toContain('md:block');
-    });
-
-    it('should handle hiddenOn at xs breakpoint', () => {
-      const config = { hiddenOn: ['xs'] } as SpecResponsiveConfig;
-      const classes = getVisibilityClasses(config);
-
-      expect(classes).toContain('hidden');
-      expect(classes).toContain('sm:block');
-    });
-  });
-
-  // ==========================================================================
-  // getColumnClasses
-  // ==========================================================================
-  describe('getColumnClasses', () => {
-    it('should return empty array when no columns set', () => {
-      const config = {} as SpecResponsiveConfig;
-      expect(getColumnClasses(config)).toEqual([]);
-    });
-
-    it('should return grid-cols classes for each breakpoint', () => {
-      const config = {
-        columns: { xs: 1, md: 2, xl: 4 },
-      } as SpecResponsiveConfig;
-      const classes = getColumnClasses(config);
-
-      expect(classes).toContain('grid-cols-1');
-      expect(classes).toContain('md:grid-cols-2');
-      expect(classes).toContain('xl:grid-cols-4');
-    });
-
-    it('should omit prefix for xs breakpoint', () => {
-      const config = { columns: { xs: 3 } } as SpecResponsiveConfig;
-      const classes = getColumnClasses(config);
-
-      expect(classes).toEqual(['grid-cols-3']);
-    });
-  });
-
-  // ==========================================================================
-  // getOrderClasses
-  // ==========================================================================
-  describe('getOrderClasses', () => {
-    it('should return empty array when no order set', () => {
-      const config = {} as SpecResponsiveConfig;
-      expect(getOrderClasses(config)).toEqual([]);
-    });
-
-    it('should return order classes for each breakpoint', () => {
-      const config = {
-        order: { xs: 2, lg: 1 },
-      } as SpecResponsiveConfig;
-      const classes = getOrderClasses(config);
-
-      expect(classes).toContain('order-2');
-      expect(classes).toContain('lg:order-1');
-    });
-  });
-
-  // ==========================================================================
-  // shouldHideAtBreakpoint
-  // ==========================================================================
-  describe('shouldHideAtBreakpoint', () => {
-    it('should hide below minimum breakpoint', () => {
-      const config = { breakpoint: 'md' } as SpecResponsiveConfig;
-
-      expect(shouldHideAtBreakpoint(config, 600)).toBe(true); // below 768
-      expect(shouldHideAtBreakpoint(config, 768)).toBe(false); // at 768
-      expect(shouldHideAtBreakpoint(config, 1024)).toBe(false); // above 768
-    });
-
-    it('should hide at breakpoints in hiddenOn list', () => {
-      const config = { hiddenOn: ['sm', 'lg'] } as SpecResponsiveConfig;
-
-      expect(shouldHideAtBreakpoint(config, 700)).toBe(true); // sm range
-      expect(shouldHideAtBreakpoint(config, 800)).toBe(false); // md range
-      expect(shouldHideAtBreakpoint(config, 1100)).toBe(true); // lg range
-    });
-
-    it('should return false when no config constraints', () => {
-      const config = {} as SpecResponsiveConfig;
-      expect(shouldHideAtBreakpoint(config, 500)).toBe(false);
-    });
-
-    it('should not hide at xs width when no constraints', () => {
-      const config = {} as SpecResponsiveConfig;
-      expect(shouldHideAtBreakpoint(config, 0)).toBe(false);
-    });
-  });
-});