@getmicdrop/svelte-components 5.17.0 → 5.17.3

package/dist/utils/greetings.js

@@ -1,187 +1,187 @@
-/**
- * Time-based and contextual greeting system
- * Uses user's local timezone for time-based greetings
- *
- * Persistence: Greetings are cached and only regenerate when
- * the time period OR day changes, whichever comes first.
- */
-
-const STORAGE_KEY = 'micdrop_greeting';
-
-const GREETINGS = {
-  earlyMorning: [
-    "Early-bird {name}!"
-  ],
-  morning: [
-    "Good morning, {name}",
-    "Morning, {name}"
-  ],
-  afternoon: [
-    "Good afternoon, {name}",
-    "Afternoon, {name}"
-  ],
-  evening: [
-    "Good evening, {name}",
-    "Evening, {name}",
-    "Prime time, {name}"
-  ],
-  night: [
-    "Night owl {name}!",
-    "Night-mode {name}!",
-    "Night shift {name}!"
-  ],
-  lateNight: [
-    "Late-night {name}!",
-    "After-hours {name}!"
-  ],
-  random: [
-    "Ready to roll, {name}",
-    "Good to see you, {name}",
-    "Let's go, {name}",
-    "Right on time, {name}",
-    "{name} in the house!",
-    "{name} arrives!"
-  ],
-  weekday: {
-    0: "Weekend {name}!", // Sunday
-    1: "Happy Monday, {name}",
-    2: "Happy Tuesday, {name}",
-    3: "Happy Wednesday, {name}",
-    4: "Happy Thursday, {name}",
-    5: "Happy Friday, {name}",
-    6: "Weekend {name}!" // Saturday
-  }
-};
-
-/**
- * Get a random item from an array
- */
-function pickRandom(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-
-/**
- * Get the time period based on hour (0-23)
- */
-function getTimePeriod(hour) {
-  if (hour >= 5 && hour < 7) return 'earlyMorning';
-  if (hour >= 7 && hour < 12) return 'morning';
-  if (hour >= 12 && hour < 17) return 'afternoon';
-  if (hour >= 17 && hour < 21) return 'evening';
-  if (hour >= 21 && hour < 24) return 'night';
-  // 0-5 AM
-  return 'lateNight';
-}
-
-/**
- * Get the current date as YYYY-MM-DD string
- */
-function getDateString(date) {
-  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
-}
-
-/**
- * Generate a fresh greeting (internal - does not cache)
- *
- * Priority:
- * 1. Day-based (Mon-Sun) → 30% chance
- * 2. Random pool → 30% chance
- * 3. Time-based → 40% (default)
- */
-function generateGreeting(name, hour, dayOfWeek) {
-  const roll = Math.random();
-
-  let greeting;
-
-  if (roll < 0.3) {
-    // 30% - Day-based greeting
-    greeting = GREETINGS.weekday[dayOfWeek];
-  } else if (roll < 0.6) {
-    // 30% - Random greeting
-    greeting = pickRandom(GREETINGS.random);
-  } else {
-    // 40% - Time-based greeting
-    const period = getTimePeriod(hour);
-    greeting = pickRandom(GREETINGS[period]);
-  }
-
-  return greeting.replace('{name}', name);
-}
-
-/**
- * Get a greeting for the user with caching
- *
- * Regenerates when time period OR day changes, whichever comes first.
- * This ensures:
- * - Navigation between pages shows same greeting
- * - Coming back hours later (different period) shows fresh greeting
- * - Day-based greetings don't persist into the next day
- *
- * @param {string} name - The user's first name
- * @returns {string} The greeting with name substituted
- */
-export function getGreeting(name) {
-  if (typeof window === 'undefined') {
-    // SSR - generate without caching
-    const now = new Date();
-    return generateGreeting(name, now.getHours(), now.getDay());
-  }
-
-  const now = new Date();
-  const currentPeriod = getTimePeriod(now.getHours());
-  const currentDay = getDateString(now);
-
-  // Check for cached greeting
-  try {
-    const cached = localStorage.getItem(STORAGE_KEY);
-    if (cached) {
-      const { greeting, period, day, cachedName } = JSON.parse(cached);
-
-      // Return cached if same period, same day, and same user
-      if (period === currentPeriod && day === currentDay && cachedName === name) {
-        return greeting;
-      }
-    }
-  } catch (_e) {
-    // localStorage unavailable or parse error - continue to generate
-  }
-
-  // Generate fresh greeting
-  const greeting = generateGreeting(name, now.getHours(), now.getDay());
-
-  // Cache it
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify({
-      greeting,
-      period: currentPeriod,
-      day: currentDay,
-      cachedName: name
-    }));
-  } catch (_e2) {
-    // localStorage unavailable - greeting still works, just won't persist
-  }
-
-  return greeting;
-}
-
-/**
- * Get just the first name from a full name
- * @param {string} fullName - The user's full name
- * @returns {string} The first name only
- */
-export function getFirstName(fullName) {
-  if (!fullName) return '';
-  return fullName.split(' ')[0];
-}
-
-/**
- * Clear the cached greeting (useful for testing or logout)
- */
-export function clearGreetingCache() {
-  if (typeof window === 'undefined') return;
-  try {
-    localStorage.removeItem(STORAGE_KEY);
-  } catch (_e) {
-    // localStorage unavailable
-  }
-}
+/**
+ * Time-based and contextual greeting system
+ * Uses user's local timezone for time-based greetings
+ *
+ * Persistence: Greetings are cached and only regenerate when
+ * the time period OR day changes, whichever comes first.
+ */
+
+const STORAGE_KEY = 'micdrop_greeting';
+
+const GREETINGS = {
+  earlyMorning: [
+    "Early-bird {name}!"
+  ],
+  morning: [
+    "Good morning, {name}",
+    "Morning, {name}"
+  ],
+  afternoon: [
+    "Good afternoon, {name}",
+    "Afternoon, {name}"
+  ],
+  evening: [
+    "Good evening, {name}",
+    "Evening, {name}",
+    "Prime time, {name}"
+  ],
+  night: [
+    "Night owl {name}!",
+    "Night-mode {name}!",
+    "Night shift {name}!"
+  ],
+  lateNight: [
+    "Late-night {name}!",
+    "After-hours {name}!"
+  ],
+  random: [
+    "Ready to roll, {name}",
+    "Good to see you, {name}",
+    "Let's go, {name}",
+    "Right on time, {name}",
+    "{name} in the house!",
+    "{name} arrives!"
+  ],
+  weekday: {
+    0: "Weekend {name}!", // Sunday
+    1: "Happy Monday, {name}",
+    2: "Happy Tuesday, {name}",
+    3: "Happy Wednesday, {name}",
+    4: "Happy Thursday, {name}",
+    5: "Happy Friday, {name}",
+    6: "Weekend {name}!" // Saturday
+  }
+};
+
+/**
+ * Get a random item from an array
+ */
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Get the time period based on hour (0-23)
+ */
+function getTimePeriod(hour) {
+  if (hour >= 5 && hour < 7) return 'earlyMorning';
+  if (hour >= 7 && hour < 12) return 'morning';
+  if (hour >= 12 && hour < 17) return 'afternoon';
+  if (hour >= 17 && hour < 21) return 'evening';
+  if (hour >= 21 && hour < 24) return 'night';
+  // 0-5 AM
+  return 'lateNight';
+}
+
+/**
+ * Get the current date as YYYY-MM-DD string
+ */
+function getDateString(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
+
+/**
+ * Generate a fresh greeting (internal - does not cache)
+ *
+ * Priority:
+ * 1. Day-based (Mon-Sun) → 30% chance
+ * 2. Random pool → 30% chance
+ * 3. Time-based → 40% (default)
+ */
+function generateGreeting(name, hour, dayOfWeek) {
+  const roll = Math.random();
+
+  let greeting;
+
+  if (roll < 0.3) {
+    // 30% - Day-based greeting
+    greeting = GREETINGS.weekday[dayOfWeek];
+  } else if (roll < 0.6) {
+    // 30% - Random greeting
+    greeting = pickRandom(GREETINGS.random);
+  } else {
+    // 40% - Time-based greeting
+    const period = getTimePeriod(hour);
+    greeting = pickRandom(GREETINGS[period]);
+  }
+
+  return greeting.replace('{name}', name);
+}
+
+/**
+ * Get a greeting for the user with caching
+ *
+ * Regenerates when time period OR day changes, whichever comes first.
+ * This ensures:
+ * - Navigation between pages shows same greeting
+ * - Coming back hours later (different period) shows fresh greeting
+ * - Day-based greetings don't persist into the next day
+ *
+ * @param {string} name - The user's first name
+ * @returns {string} The greeting with name substituted
+ */
+export function getGreeting(name) {
+  if (typeof window === 'undefined') {
+    // SSR - generate without caching
+    const now = new Date();
+    return generateGreeting(name, now.getHours(), now.getDay());
+  }
+
+  const now = new Date();
+  const currentPeriod = getTimePeriod(now.getHours());
+  const currentDay = getDateString(now);
+
+  // Check for cached greeting
+  try {
+    const cached = localStorage.getItem(STORAGE_KEY);
+    if (cached) {
+      const { greeting, period, day, cachedName } = JSON.parse(cached);
+
+      // Return cached if same period, same day, and same user
+      if (period === currentPeriod && day === currentDay && cachedName === name) {
+        return greeting;
+      }
+    }
+  } catch (_e) {
+    // localStorage unavailable or parse error - continue to generate
+  }
+
+  // Generate fresh greeting
+  const greeting = generateGreeting(name, now.getHours(), now.getDay());
+
+  // Cache it
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({
+      greeting,
+      period: currentPeriod,
+      day: currentDay,
+      cachedName: name
+    }));
+  } catch (_e2) {
+    // localStorage unavailable - greeting still works, just won't persist
+  }
+
+  return greeting;
+}
+
+/**
+ * Get just the first name from a full name
+ * @param {string} fullName - The user's full name
+ * @returns {string} The first name only
+ */
+export function getFirstName(fullName) {
+  if (!fullName) return '';
+  return fullName.split(' ')[0];
+}
+
+/**
+ * Clear the cached greeting (useful for testing or logout)
+ */
+export function clearGreetingCache() {
+  if (typeof window === 'undefined') return;
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch (_e) {
+    // localStorage unavailable
+  }
+}

package/dist/utils/haptic.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=haptic.spec.d.ts.map

package/dist/utils/haptic.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"haptic.spec.d.ts","sourceRoot":"","sources":["../../src/lib/utils/haptic.spec.ts"],"names":[],"mappings":""}

package/dist/utils/haptic.spec.js

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { triggerHaptic, isHapticAvailable, getHapticForButtonVariant } from './haptic';
+describe('haptic', () => {
+    const originalWindow = globalThis.window;
+    afterEach(() => {
+        vi.restoreAllMocks();
+        // Clean up any added properties
+        // @ts-expect-error cleanup
+        delete window.webkit;
+        // @ts-expect-error cleanup
+        delete window.TapticEngine;
+    });
+    describe('triggerHaptic', () => {
+        it('returns early in non-browser environment', () => {
+            const windowSpy = vi.spyOn(globalThis, 'window', 'get');
+            // @ts-expect-error simulating server
+            windowSpy.mockReturnValue(undefined);
+            expect(() => triggerHaptic('light')).not.toThrow();
+            windowSpy.mockRestore();
+        });
+        it('uses iOS WebKit messageHandlers when available', () => {
+            const postMessage = vi.fn();
+            // @ts-expect-error mock iOS WebKit
+            window.webkit = { messageHandlers: { haptic: { postMessage } } };
+            triggerHaptic('success');
+            expect(postMessage).toHaveBeenCalledWith('success');
+        });
+        it('uses TapticEngine when available', () => {
+            const impact = vi.fn();
+            // @ts-expect-error mock TapticEngine
+            window.TapticEngine = { impact };
+            triggerHaptic('light');
+            expect(impact).toHaveBeenCalledWith({ style: 'light' });
+        });
+        it('maps success/warning/error/selection to medium for TapticEngine', () => {
+            const impact = vi.fn();
+            // @ts-expect-error mock TapticEngine
+            window.TapticEngine = { impact };
+            triggerHaptic('success');
+            expect(impact).toHaveBeenCalledWith({ style: 'medium' });
+            triggerHaptic('warning');
+            expect(impact).toHaveBeenCalledWith({ style: 'medium' });
+            triggerHaptic('error');
+            expect(impact).toHaveBeenCalledWith({ style: 'medium' });
+            triggerHaptic('selection');
+            expect(impact).toHaveBeenCalledWith({ style: 'medium' });
+        });
+        it('passes through light/medium/heavy to TapticEngine', () => {
+            const impact = vi.fn();
+            // @ts-expect-error mock TapticEngine
+            window.TapticEngine = { impact };
+            triggerHaptic('heavy');
+            expect(impact).toHaveBeenCalledWith({ style: 'heavy' });
+            triggerHaptic('medium');
+            expect(impact).toHaveBeenCalledWith({ style: 'medium' });
+        });
+        it('falls back to Vibration API', () => {
+            const vibrate = vi.fn();
+            Object.defineProperty(navigator, 'vibrate', { value: vibrate, writable: true, configurable: true });
+            triggerHaptic('light');
+            expect(vibrate).toHaveBeenCalledWith(10);
+            triggerHaptic('medium');
+            expect(vibrate).toHaveBeenCalledWith(20);
+            triggerHaptic('heavy');
+            expect(vibrate).toHaveBeenCalledWith(30);
+            triggerHaptic('success');
+            expect(vibrate).toHaveBeenCalledWith([10, 50, 20]);
+            triggerHaptic('warning');
+            expect(vibrate).toHaveBeenCalledWith([20, 40, 20]);
+            triggerHaptic('error');
+            expect(vibrate).toHaveBeenCalledWith([30, 50, 30, 50, 30]);
+            triggerHaptic('selection');
+            expect(vibrate).toHaveBeenCalledWith(8);
+            // cleanup
+            Object.defineProperty(navigator, 'vibrate', { value: undefined, writable: true, configurable: true });
+        });
+        it('defaults to light when no style specified', () => {
+            const vibrate = vi.fn();
+            Object.defineProperty(navigator, 'vibrate', { value: vibrate, writable: true, configurable: true });
+            triggerHaptic();
+            expect(vibrate).toHaveBeenCalledWith(10);
+            Object.defineProperty(navigator, 'vibrate', { value: undefined, writable: true, configurable: true });
+        });
+        it('does nothing when no haptic API available', () => {
+            // No webkit, no TapticEngine, no vibrate
+            Object.defineProperty(navigator, 'vibrate', { value: undefined, writable: true, configurable: true });
+            expect(() => triggerHaptic('light')).not.toThrow();
+        });
+    });
+    describe('isHapticAvailable', () => {
+        it('returns false in non-browser environment', () => {
+            const windowSpy = vi.spyOn(globalThis, 'window', 'get');
+            // @ts-expect-error simulating server
+            windowSpy.mockReturnValue(undefined);
+            expect(isHapticAvailable()).toBe(false);
+            windowSpy.mockRestore();
+        });
+        it('returns true when webkit haptic handler exists', () => {
+            // @ts-expect-error mock
+            window.webkit = { messageHandlers: { haptic: { postMessage: vi.fn() } } };
+            expect(isHapticAvailable()).toBe(true);
+        });
+        it('returns true when TapticEngine exists', () => {
+            // @ts-expect-error mock
+            window.TapticEngine = { impact: vi.fn() };
+            expect(isHapticAvailable()).toBe(true);
+        });
+        it('returns true when vibrate exists', () => {
+            Object.defineProperty(navigator, 'vibrate', { value: vi.fn(), writable: true, configurable: true });
+            expect(isHapticAvailable()).toBe(true);
+            Object.defineProperty(navigator, 'vibrate', { value: undefined, writable: true, configurable: true });
+        });
+        it('returns false when no haptic API available', () => {
+            Object.defineProperty(navigator, 'vibrate', { value: undefined, writable: true, configurable: true });
+            expect(isHapticAvailable()).toBe(false);
+        });
+    });
+    describe('getHapticForButtonVariant', () => {
+        it('returns success when isSuccess is true regardless of variant', () => {
+            expect(getHapticForButtonVariant('default', true)).toBe('success');
+            expect(getHapticForButtonVariant('ghost', true)).toBe('success');
+        });
+        it('returns heavy for destructive variants', () => {
+            expect(getHapticForButtonVariant('red')).toBe('heavy');
+            expect(getHapticForButtonVariant('red-outline')).toBe('heavy');
+            expect(getHapticForButtonVariant('ghost-red')).toBe('heavy');
+            expect(getHapticForButtonVariant('menu-item-danger')).toBe('heavy');
+        });
+        it('returns medium for primary action variants', () => {
+            expect(getHapticForButtonVariant('default')).toBe('medium');
+            expect(getHapticForButtonVariant('outline')).toBe('medium');
+            expect(getHapticForButtonVariant('landing')).toBe('medium');
+        });
+        it('returns light for secondary action variants', () => {
+            expect(getHapticForButtonVariant('alternative')).toBe('light');
+            expect(getHapticForButtonVariant('ghost')).toBe('light');
+            expect(getHapticForButtonVariant('landing-secondary')).toBe('light');
+        });
+        it('returns selection for toggle/nav variants', () => {
+            expect(getHapticForButtonVariant('toggle')).toBe('selection');
+            expect(getHapticForButtonVariant('nav')).toBe('selection');
+        });
+        it('returns null for variants that should not have haptic', () => {
+            expect(getHapticForButtonVariant('icon')).toBeNull();
+            expect(getHapticForButtonVariant('menu-item')).toBeNull();
+            expect(getHapticForButtonVariant('search-result')).toBeNull();
+            expect(getHapticForButtonVariant('link')).toBeNull();
+        });
+        it('returns light for unknown variants', () => {
+            expect(getHapticForButtonVariant('unknown-variant')).toBe('light');
+        });
+    });
+});

package/dist/utils/imageOptimizer.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=imageOptimizer.spec.d.ts.map

package/dist/utils/imageOptimizer.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageOptimizer.spec.d.ts","sourceRoot":"","sources":["../../src/lib/utils/imageOptimizer.spec.ts"],"names":[],"mappings":""}