@getmicdrop/svelte-components 5.5.1 → 5.5.5

package/dist/datetime/__tests__/timezone.test.js

@@ -1,5 +1,5 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getTimezoneDisplayName, getTimezoneOffset, getUserTimezone, getVenueTimezone, isDST, isValidTimezone, normalizeTimezone, } from '../timezone';
+import { describe, expect, it } from 'vitest';
+import { getTimezoneDisplayName, getTimezoneOffset, getUserTimezone, getVenueTimezone, isDST, isValidTimezone, normalizeTimezone, getIANATimezone, isValidIANATimezone, getAllTimezones, formatTimezoneForDisplay, getTimezoneOptions, getCommonUSTimezoneOptions, } from '../timezone';
 import { DateTimeError, DateTimeErrorCode } from '../types';
 describe('timezone utilities', () => {
     describe('isValidTimezone', () => {
@@ -211,4 +211,126 @@ describe('timezone utilities', () => {
             expect(() => isDST('Invalid/Zone')).toThrow(DateTimeError);
         });
     });
+    describe('getIANATimezone', () => {
+        it('returns default timezone for null or undefined', () => {
+            expect(getIANATimezone(null)).toBe('America/Los_Angeles');
+            expect(getIANATimezone(undefined)).toBe('America/Los_Angeles');
+        });
+        it('returns default timezone for "NaN" string', () => {
+            expect(getIANATimezone('NaN')).toBe('America/Los_Angeles');
+        });
+        it('converts legacy timezone strings', () => {
+            // Check LEGACY_TIMEZONE_MAP from constants
+            expect(getIANATimezone('California USA')).toBe('America/Los_Angeles');
+        });
+        it('returns valid IANA timezone as-is', () => {
+            expect(getIANATimezone('America/New_York')).toBe('America/New_York');
+            expect(getIANATimezone('Europe/London')).toBe('Europe/London');
+            expect(getIANATimezone('Asia/Tokyo')).toBe('Asia/Tokyo');
+        });
+        it('normalizes timezone abbreviations', () => {
+            expect(getIANATimezone('PST')).toBe('America/Los_Angeles');
+            expect(getIANATimezone('EST')).toBe('America/New_York');
+            expect(getIANATimezone('CST')).toBe('America/Chicago');
+        });
+        it('returns default timezone for invalid input', () => {
+            expect(getIANATimezone('Invalid/Zone')).toBe('America/Los_Angeles');
+            expect(getIANATimezone('UNKNOWN')).toBe('America/Los_Angeles');
+        });
+    });
+    describe('isValidIANATimezone', () => {
+        it('is an alias for isValidTimezone', () => {
+            expect(isValidIANATimezone('America/Los_Angeles')).toBe(true);
+            expect(isValidIANATimezone('Invalid/Zone')).toBe(false);
+        });
+    });
+    describe('getAllTimezones', () => {
+        it('returns an array of timezone identifiers', () => {
+            const timezones = getAllTimezones();
+            expect(Array.isArray(timezones)).toBe(true);
+            expect(timezones.length).toBeGreaterThan(0);
+        });
+        it('includes common timezones', () => {
+            const timezones = getAllTimezones();
+            expect(timezones).toContain('America/Los_Angeles');
+            expect(timezones).toContain('America/New_York');
+            expect(timezones).toContain('Europe/London');
+        });
+    });
+    describe('formatTimezoneForDisplay', () => {
+        it('formats timezone with abbreviation', () => {
+            const formatted = formatTimezoneForDisplay('America/Los_Angeles');
+            expect(formatted).toContain('America / Los Angeles');
+            expect(formatted).toMatch(/\(P[SD]T\)/);
+        });
+        it('formats timezone with underscores replaced', () => {
+            const formatted = formatTimezoneForDisplay('America/New_York');
+            expect(formatted).toContain('America / New York');
+        });
+        it('handles UTC', () => {
+            const formatted = formatTimezoneForDisplay('UTC');
+            expect(formatted).toContain('UTC');
+        });
+        it('falls back gracefully for invalid timezones', () => {
+            const formatted = formatTimezoneForDisplay('Invalid/Zone');
+            expect(typeof formatted).toBe('string');
+            expect(formatted).toContain('Invalid');
+        });
+    });
+    describe('getTimezoneOptions', () => {
+        it('returns array of timezone options', () => {
+            const options = getTimezoneOptions();
+            expect(Array.isArray(options)).toBe(true);
+            expect(options.length).toBeGreaterThan(0);
+        });
+        it('has correct structure with value and name', () => {
+            const options = getTimezoneOptions();
+            options.forEach(option => {
+                expect(option).toHaveProperty('value');
+                expect(option).toHaveProperty('name');
+                expect(typeof option.value).toBe('string');
+                expect(typeof option.name).toBe('string');
+            });
+        });
+        it('includes common timezones', () => {
+            const options = getTimezoneOptions();
+            const values = options.map(opt => opt.value);
+            expect(values).toContain('America/Los_Angeles');
+            expect(values).toContain('America/New_York');
+        });
+    });
+    describe('getCommonUSTimezoneOptions', () => {
+        it('returns array of common US timezone options', () => {
+            const options = getCommonUSTimezoneOptions();
+            expect(Array.isArray(options)).toBe(true);
+            expect(options.length).toBe(7);
+        });
+        it('has correct structure with value and name', () => {
+            const options = getCommonUSTimezoneOptions();
+            options.forEach(option => {
+                expect(option).toHaveProperty('value');
+                expect(option).toHaveProperty('name');
+                expect(typeof option.value).toBe('string');
+                expect(typeof option.name).toBe('string');
+            });
+        });
+        it('includes all major US timezones', () => {
+            const options = getCommonUSTimezoneOptions();
+            const values = options.map(opt => opt.value);
+            expect(values).toContain('America/Los_Angeles');
+            expect(values).toContain('America/Denver');
+            expect(values).toContain('America/Phoenix');
+            expect(values).toContain('America/Chicago');
+            expect(values).toContain('America/New_York');
+            expect(values).toContain('America/Anchorage');
+            expect(values).toContain('Pacific/Honolulu');
+        });
+        it('formats names correctly', () => {
+            const options = getCommonUSTimezoneOptions();
+            options.forEach(option => {
+                expect(option.name).toContain('/');
+                expect(option.name).toMatch(/\([A-Z]+\)/);
+            });
+        });
+    });
 });

package/dist/datetime/parse.js

@@ -6,7 +6,7 @@
  *
  * @module datetime/parse
  */
-import { format, parse } from 'date-fns';
+import { format } from 'date-fns';
 import { fromZonedTime, toZonedTime } from 'date-fns-tz';
 import { DATE_FORMATS } from './constants';
 import { isValidTimezone } from './timezone';

package/dist/forms/createFieldTracker.spec.d.ts

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

package/dist/forms/createFieldTracker.spec.d.ts.map

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

package/dist/forms/createFieldTracker.spec.js

@@ -0,0 +1,343 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, cleanup } from '@testing-library/svelte';
+import { tick } from 'svelte';
+
+// Test wrapper component to use the field tracker
+// We need a Svelte component to test reactive behavior
+const createTestComponent = () => {
+  const script = `
+    <script>
+      import { createFieldTracker } from './createFieldTracker.svelte.ts';
+
+      let { initialDirty = false, tracker: trackerRef = null } = $props();
+      let dirtyValue = $state(initialDirty);
+
+      const tracker = createFieldTracker(() => dirtyValue);
+
+      // Expose tracker via bindable prop
+      $effect(() => {
+        if (trackerRef) {
+          trackerRef.current = tracker;
+        }
+      });
+
+      export function setDirty(value) {
+        dirtyValue = value;
+      }
+
+      export function getTracker() {
+        return tracker;
+      }
+    </script>
+    <div data-testid="tracker-test"></div>
+  `;
+
+  return script;
+};
+
+// Since we can't dynamically create components, we'll test the module directly
+// The module uses Svelte runes which require proper Svelte context
+// For this module, we'll test what we can and document limitations
+
+describe('createFieldTracker Module', () => {
+  describe('module exports', () => {
+    it('exports createFieldTracker function', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      expect(typeof createFieldTracker).toBe('function');
+    });
+  });
+
+  describe('tracker creation', () => {
+    it('creates a tracker with required properties', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      expect(tracker).toHaveProperty('isLoading');
+      expect(tracker).toHaveProperty('isSaving');
+      expect(tracker).toHaveProperty('isSaved');
+      expect(tracker).toHaveProperty('isDirty');
+      expect(tracker).toHaveProperty('canSave');
+      expect(tracker).toHaveProperty('reset');
+      expect(tracker).toHaveProperty('markSaved');
+      expect(tracker).toHaveProperty('save');
+    });
+
+    it('has correct initial state values', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      expect(tracker.isLoading).toBe(false);
+      expect(tracker.isSaving).toBe(false);
+      expect(tracker.isSaved).toBe(false);
+    });
+  });
+
+  describe('isLoading property', () => {
+    it('can be set to true', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isLoading = true;
+      expect(tracker.isLoading).toBe(true);
+    });
+
+    it('can be set back to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isLoading = true;
+      tracker.isLoading = false;
+      expect(tracker.isLoading).toBe(false);
+    });
+  });
+
+  describe('isSaving property', () => {
+    it('can be set to true', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaving = true;
+      expect(tracker.isSaving).toBe(true);
+    });
+
+    it('can be set back to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaving = true;
+      tracker.isSaving = false;
+      expect(tracker.isSaving).toBe(false);
+    });
+  });
+
+  describe('isSaved property', () => {
+    it('can be set to true', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaved = true;
+      expect(tracker.isSaved).toBe(true);
+    });
+
+    it('can be set back to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaved = true;
+      tracker.isSaved = false;
+      expect(tracker.isSaved).toBe(false);
+    });
+  });
+
+  describe('isDirty property', () => {
+    it('reflects isDirtyFn return value when false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      expect(tracker.isDirty).toBe(false);
+    });
+
+    it('reflects isDirtyFn return value when true', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      expect(tracker.isDirty).toBe(true);
+    });
+  });
+
+  describe('canSave method', () => {
+    it('returns false when not dirty and valid', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      expect(tracker.canSave(true)).toBe(false);
+    });
+
+    it('returns false when dirty but not valid', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      expect(tracker.canSave(false)).toBe(false);
+    });
+
+    it('returns true when dirty and valid', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      expect(tracker.canSave(true)).toBe(true);
+    });
+
+    it('returns false when saving', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      tracker.isSaving = true;
+      expect(tracker.canSave(true)).toBe(false);
+    });
+  });
+
+  describe('reset method', () => {
+    it('resets isLoading to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isLoading = true;
+      tracker.reset();
+      expect(tracker.isLoading).toBe(false);
+    });
+
+    it('resets isSaving to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaving = true;
+      tracker.reset();
+      expect(tracker.isSaving).toBe(false);
+    });
+
+    it('resets isSaved to false', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isSaved = true;
+      tracker.reset();
+      expect(tracker.isSaved).toBe(false);
+    });
+
+    it('resets all states at once', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.isLoading = true;
+      tracker.isSaving = true;
+      tracker.isSaved = true;
+      tracker.reset();
+
+      expect(tracker.isLoading).toBe(false);
+      expect(tracker.isSaving).toBe(false);
+      expect(tracker.isSaved).toBe(false);
+    });
+  });
+
+  describe('markSaved method', () => {
+    it('sets isSaved to true', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.markSaved();
+      expect(tracker.isSaved).toBe(true);
+    });
+
+    it('can mark saved multiple times', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      tracker.markSaved();
+      tracker.isSaved = false;
+      tracker.markSaved();
+      expect(tracker.isSaved).toBe(true);
+    });
+  });
+
+  describe('save method', () => {
+    it('sets isSaving to true during save', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      let savingDuringSave = false;
+      await tracker.save(async () => {
+        savingDuringSave = tracker.isSaving;
+        return 'result';
+      });
+
+      expect(savingDuringSave).toBe(true);
+    });
+
+    it('sets isSaving to false after save completes', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      await tracker.save(async () => 'result');
+
+      expect(tracker.isSaving).toBe(false);
+    });
+
+    it('sets isSaved to true after successful save', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      await tracker.save(async () => 'result');
+
+      expect(tracker.isSaved).toBe(true);
+    });
+
+    it('returns the result from the save function', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      const result = await tracker.save(async () => 'test result');
+
+      expect(result).toBe('test result');
+    });
+
+    it('returns typed result', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      const result = await tracker.save(async () => ({ id: 1, name: 'test' }));
+
+      expect(result).toEqual({ id: 1, name: 'test' });
+    });
+
+    it('sets isSaving to false even if save throws', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      try {
+        await tracker.save(async () => {
+          throw new Error('Save failed');
+        });
+      } catch {
+        // Expected
+      }
+
+      expect(tracker.isSaving).toBe(false);
+    });
+
+    it('propagates errors from save function', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      await expect(tracker.save(async () => {
+        throw new Error('Save failed');
+      })).rejects.toThrow('Save failed');
+    });
+
+    it('does not set isSaved if save throws', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => true);
+
+      try {
+        await tracker.save(async () => {
+          throw new Error('Save failed');
+        });
+      } catch {
+        // Expected
+      }
+
+      expect(tracker.isSaved).toBe(false);
+    });
+  });
+
+  describe('type interface', () => {
+    it('methods are callable', async () => {
+      const { createFieldTracker } = await import('./createFieldTracker.svelte.ts');
+      const tracker = createFieldTracker(() => false);
+
+      expect(typeof tracker.canSave).toBe('function');
+      expect(typeof tracker.reset).toBe('function');
+      expect(typeof tracker.markSaved).toBe('function');
+      expect(typeof tracker.save).toBe('function');
+    });
+  });
+});

package/dist/forms/createFormStore.spec.d.ts

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

package/dist/forms/createFormStore.spec.d.ts.map

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