@getmicdrop/svelte-components 5.5.4 → 5.6.0

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":""}