@bendyline/squisq 0.1.1

package/src/__tests__/geohash.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import {
+  encodeGeohash,
+  decodeGeohash,
+  getNeighbors,
+  getGeohash4Neighbors,
+  getGeohashPrefix,
+  geohashToHierarchicalPath,
+  getGeohashPath,
+  geohashOverlapsBounds,
+} from '../spatial/Geohash';
+
+describe('encodeGeohash / decodeGeohash round-trip', () => {
+  it('encodes and decodes Seattle', () => {
+    const lat = 47.6062;
+    const lng = -122.3321;
+    const hash = encodeGeohash(lat, lng, 6);
+    expect(hash).toHaveLength(6);
+
+    const decoded = decodeGeohash(hash);
+    expect(decoded.lat).toBeCloseTo(lat, 1);
+    expect(decoded.lng).toBeCloseTo(lng, 1);
+  });
+
+  it('encodes and decodes equator/prime meridian', () => {
+    const hash = encodeGeohash(0, 0, 4);
+    expect(hash).toHaveLength(4);
+    const decoded = decodeGeohash(hash);
+    expect(decoded.lat).toBeCloseTo(0, 0);
+    expect(decoded.lng).toBeCloseTo(0, 0);
+  });
+
+  it('defaults to precision 9', () => {
+    const hash = encodeGeohash(47.6, -122.3);
+    expect(hash).toHaveLength(9);
+  });
+});
+
+describe('getNeighbors', () => {
+  it('returns 8 neighbors', () => {
+    const neighbors = getNeighbors('c23n');
+    expect(neighbors).toHaveLength(8);
+    neighbors.forEach((n) => expect(n).toHaveLength(4));
+  });
+});
+
+describe('getGeohash4Neighbors', () => {
+  it('returns center + 8 neighbors (9 total)', () => {
+    const result = getGeohash4Neighbors('c23n');
+    expect(result).toHaveLength(9);
+    expect(result[0]).toBe('c23n');
+  });
+
+  it('throws for non-4-char input', () => {
+    expect(() => getGeohash4Neighbors('c2')).toThrow();
+    expect(() => getGeohash4Neighbors('c23nn')).toThrow();
+  });
+});
+
+describe('getGeohashPrefix', () => {
+  it('extracts prefix', () => {
+    expect(getGeohashPrefix('c23nxy', 4)).toBe('c23n');
+    expect(getGeohashPrefix('c23nxy', 2)).toBe('c2');
+  });
+});
+
+describe('geohashToHierarchicalPath', () => {
+  it('converts 4-char geohash to path', () => {
+    expect(geohashToHierarchicalPath('c23n')).toBe('c/2/3/n');
+    expect(geohashToHierarchicalPath('9q8y')).toBe('9/q/8/y');
+  });
+
+  it('throws for non-4-char input', () => {
+    expect(() => geohashToHierarchicalPath('c2')).toThrow();
+  });
+});
+
+describe('getGeohashPath', () => {
+  it('returns empty for same cell', () => {
+    expect(getGeohashPath('c23n', 'c23n')).toEqual([]);
+  });
+
+  it('returns intermediate cells between two geohashes', () => {
+    const path = getGeohashPath('c23n', 'c24k');
+    expect(path.length).toBeGreaterThan(0);
+    path.forEach((h) => {
+      expect(h).toHaveLength(4);
+      expect(h).not.toBe('c23n');
+      expect(h).not.toBe('c24k');
+    });
+  });
+});
+
+describe('geohashOverlapsBounds', () => {
+  it('detects overlap', () => {
+    // Seattle area: c23n
+    const bounds = { north: 48, south: 47, east: -122, west: -123 };
+    const hash = encodeGeohash(47.6, -122.3, 4);
+    expect(geohashOverlapsBounds(hash, bounds)).toBe(true);
+  });
+
+  it('detects non-overlap', () => {
+    // Tokyo area bounds
+    const bounds = { north: 36, south: 35, east: 140, west: 139 };
+    // Seattle geohash
+    const hash = encodeGeohash(47.6, -122.3, 4);
+    expect(geohashOverlapsBounds(hash, bounds)).toBe(false);
+  });
+});

package/src/__tests__/getLayers.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi } from 'vitest';
+import { getLayers, RenderContext } from '../doc/getLayers.js';
+import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
+import { TemplateBlock, PersistentLayerConfig } from '../schemas/BlockTemplates.js';
+import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
+import type { Block, Layer, TextLayer, ShapeLayer } from '../schemas/Doc.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeTemplateBlock(overrides: Partial<TemplateBlock> = {}): TemplateBlock {
+  return {
+    template: 'titleBlock',
+    id: 'test-title-1',
+    duration: 5,
+    audioSegment: 0,
+    title: 'Hello World',
+    ...overrides,
+  } as TemplateBlock;
+}
+
+function makeRawBlock(layers: Layer[]): Block {
+  return {
+    id: 'raw-block-1',
+    duration: 5,
+    startTime: 0,
+    audioSegment: 0,
+    layers,
+  };
+}
+
+const defaultContext: RenderContext = {
+  theme: DEFAULT_THEME,
+  viewport: VIEWPORT_PRESETS.landscape,
+  blockIndex: 0,
+  totalBlocks: 5,
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('getLayers', () => {
+  it('generates layers for a known template block', () => {
+    const block = makeTemplateBlock({ template: 'titleBlock', title: 'Test Title' });
+    const layers = getLayers(block, defaultContext);
+
+    expect(Array.isArray(layers)).toBe(true);
+    expect(layers.length).toBeGreaterThan(0);
+
+    // titleBlock always produces at least a text layer with the title
+    const textLayer = layers.find((l) => l.type === 'text');
+    expect(textLayer).toBeDefined();
+    expect((textLayer as TextLayer).content.text).toContain('Test Title');
+  });
+
+  it('generates layers for statHighlight template', () => {
+    const block = makeTemplateBlock({
+      template: 'statHighlight',
+      stat: '42%',
+      description: 'of users',
+    });
+    const layers = getLayers(block, defaultContext);
+
+    expect(layers.length).toBeGreaterThan(0);
+    const texts = layers.filter((l) => l.type === 'text');
+    expect(texts.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('returns raw block layers when block has pre-computed layers', () => {
+    const existingLayers: Layer[] = [
+      {
+        type: 'shape',
+        id: 'test-shape',
+        content: { shape: 'rect', fill: '#ff0000' },
+        position: { x: 0, y: 0, width: 100, height: 100 },
+      } as ShapeLayer,
+    ];
+    const block = makeRawBlock(existingLayers);
+    const layers = getLayers(block, defaultContext);
+
+    expect(layers).toEqual(existingLayers);
+  });
+
+  it('returns empty array for unknown template', () => {
+    const block = {
+      template: 'totally_nonexistent',
+      id: 'unknown-1',
+      duration: 5,
+      audioSegment: 0,
+    } as unknown as TemplateBlock;
+    const layers = getLayers(block, defaultContext);
+
+    expect(layers).toEqual([]);
+  });
+
+  it('returns empty array for block with no template and no layers', () => {
+    const block: Block = { id: 'empty-1', duration: 5, startTime: 0, audioSegment: 0 };
+    const layers = getLayers(block, defaultContext);
+
+    expect(layers).toEqual([]);
+  });
+
+  it('uses default context values when context is omitted', () => {
+    const block = makeTemplateBlock({ template: 'titleBlock', title: 'Defaults' });
+    const layers = getLayers(block);
+
+    expect(Array.isArray(layers)).toBe(true);
+    expect(layers.length).toBeGreaterThan(0);
+  });
+
+  it('handles template that throws an error gracefully', () => {
+    // We spy on console.error to suppress noise and verify it was called
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    // comparisonBar requires numeric values; passing invalid data may throw
+    // but getLayers should catch and return []
+    const block = makeTemplateBlock({
+      template: 'comparisonBar',
+      // Missing required fields
+    });
+    const layers = getLayers(block, defaultContext);
+
+    expect(Array.isArray(layers)).toBe(true);
+    consoleSpy.mockRestore();
+  });
+
+  describe('persistent layers injection', () => {
+    const bottomLayer: Layer = {
+      type: 'shape',
+      id: 'bottom',
+      content: { shape: 'rect', fill: '#000' },
+      position: { x: 0, y: 0, width: 100, height: 100 },
+    } as ShapeLayer;
+
+    const topLayer: Layer = {
+      type: 'shape',
+      id: 'top',
+      content: { shape: 'rect', fill: '#fff' },
+      position: { x: 0, y: 0, width: 100, height: 100 },
+    } as ShapeLayer;
+
+    const persistentConfig: PersistentLayerConfig = {
+      bottomLayers: [bottomLayer],
+      topLayers: [topLayer],
+    };
+
+    it('injects persistent bottom and top layers around block layers', () => {
+      const block = makeTemplateBlock({ template: 'titleBlock', title: 'With Persistent' });
+      const layers = getLayers(block, { ...defaultContext, persistentLayers: persistentConfig });
+
+      // First layer should be the bottom persistent layer
+      expect(layers[0]).toEqual(bottomLayer);
+      // Last layer should be the top persistent layer
+      expect(layers[layers.length - 1]).toEqual(topLayer);
+      // Middle layers (from template) should exist
+      expect(layers.length).toBeGreaterThan(2);
+    });
+
+    it('respects useBottomLayer: false opt-out', () => {
+      const block = makeTemplateBlock({
+        template: 'titleBlock',
+        title: 'No Bottom',
+        useBottomLayer: false,
+      });
+      const layers = getLayers(block, { ...defaultContext, persistentLayers: persistentConfig });
+
+      // Should NOT start with the bottom persistent layer
+      expect(layers[0]).not.toEqual(bottomLayer);
+      // Should still end with the top persistent layer
+      expect(layers[layers.length - 1]).toEqual(topLayer);
+    });
+
+    it('respects useTopLayer: false opt-out', () => {
+      const block = makeTemplateBlock({
+        template: 'titleBlock',
+        title: 'No Top',
+        useTopLayer: false,
+      });
+      const layers = getLayers(block, { ...defaultContext, persistentLayers: persistentConfig });
+
+      // Should start with the bottom persistent layer
+      expect(layers[0]).toEqual(bottomLayer);
+      // Should NOT end with the top persistent layer
+      expect(layers[layers.length - 1]).not.toEqual(topLayer);
+    });
+
+    it('skips injection when no persistent layers are configured', () => {
+      const block = makeTemplateBlock({ template: 'titleBlock', title: 'No Persistent' });
+      const withoutPersistent = getLayers(block, defaultContext);
+      const withEmptyPersistent = getLayers(block, {
+        ...defaultContext,
+        persistentLayers: { bottomLayers: [], topLayers: [] },
+      });
+
+      expect(withoutPersistent).toEqual(withEmptyPersistent);
+    });
+  });
+});

package/src/__tests__/haversine.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { haversineDistance, calculateBearing } from '../spatial/Haversine';
+
+describe('haversineDistance', () => {
+  it('returns 0 for same point', () => {
+    const p = { lat: 47.6062, lng: -122.3321 };
+    expect(haversineDistance(p, p)).toBe(0);
+  });
+
+  it('calculates Seattle to Portland (~233 km)', () => {
+    const seattle = { lat: 47.6062, lng: -122.3321 };
+    const portland = { lat: 45.5152, lng: -122.6784 };
+    const dist = haversineDistance(seattle, portland);
+    expect(dist).toBeGreaterThan(230);
+    expect(dist).toBeLessThan(240);
+  });
+
+  it('calculates London to Paris (~344 km)', () => {
+    const london = { lat: 51.5074, lng: -0.1278 };
+    const paris = { lat: 48.8566, lng: 2.3522 };
+    const dist = haversineDistance(london, paris);
+    expect(dist).toBeGreaterThan(340);
+    expect(dist).toBeLessThan(350);
+  });
+
+  it('calculates antipodal points (~20,000 km)', () => {
+    const p1 = { lat: 0, lng: 0 };
+    const p2 = { lat: 0, lng: 180 };
+    const dist = haversineDistance(p1, p2);
+    expect(dist).toBeGreaterThan(20000);
+    expect(dist).toBeLessThan(20100);
+  });
+});
+
+describe('calculateBearing', () => {
+  it('returns ~0 for due north', () => {
+    const from = { lat: 0, lng: 0 };
+    const to = { lat: 10, lng: 0 };
+    const bearing = calculateBearing(from, to);
+    expect(bearing).toBeCloseTo(0, 0);
+  });
+
+  it('returns ~90 for due east', () => {
+    const from = { lat: 0, lng: 0 };
+    const to = { lat: 0, lng: 10 };
+    const bearing = calculateBearing(from, to);
+    expect(bearing).toBeCloseTo(90, 0);
+  });
+
+  it('returns ~180 for due south', () => {
+    const from = { lat: 10, lng: 0 };
+    const to = { lat: 0, lng: 0 };
+    const bearing = calculateBearing(from, to);
+    expect(bearing).toBeCloseTo(180, 0);
+  });
+
+  it('returns ~270 for due west', () => {
+    const from = { lat: 0, lng: 10 };
+    const to = { lat: 0, lng: 0 };
+    const bearing = calculateBearing(from, to);
+    expect(bearing).toBeCloseTo(270, 0);
+  });
+});

package/src/__tests__/localForageAdapter.test.ts

@@ -0,0 +1,155 @@
+/**
+ * LocalForageAdapter tests
+ *
+ * Uses the localforage library (which falls back to an in-memory driver
+ * in jsdom/Node environments) to verify the adapter contract.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LocalForageAdapter } from '../storage/LocalForageAdapter';
+
+describe('LocalForageAdapter', () => {
+  let storage: LocalForageAdapter;
+
+  beforeEach(async () => {
+    storage = new LocalForageAdapter({ name: 'test-db', storeName: 'test-store' });
+    await storage.clear();
+  });
+
+  it('supports enumeration', () => {
+    expect(storage.supportsEnumeration).toBe(true);
+  });
+
+  it('get returns null for missing key', async () => {
+    expect(await storage.get('nonexistent')).toBeNull();
+  });
+
+  it('set and get round-trip', async () => {
+    await storage.set('key', { hello: 'world' });
+    expect(await storage.get('key')).toEqual({ hello: 'world' });
+  });
+
+  it('stores primitives', async () => {
+    await storage.set('str', 'hello');
+    await storage.set('num', 42);
+    await storage.set('bool', true);
+    expect(await storage.get('str')).toBe('hello');
+    expect(await storage.get('num')).toBe(42);
+    expect(await storage.get('bool')).toBe(true);
+  });
+
+  it('overwrites existing values', async () => {
+    await storage.set('key', 'first');
+    await storage.set('key', 'second');
+    expect(await storage.get('key')).toBe('second');
+  });
+
+  it('remove deletes a key', async () => {
+    await storage.set('key', 'value');
+    await storage.remove('key');
+    expect(await storage.get('key')).toBeNull();
+  });
+
+  it('clear removes all keys', async () => {
+    await storage.set('a', 1);
+    await storage.set('b', 2);
+    await storage.clear();
+    expect(await storage.get('a')).toBeNull();
+    expect(await storage.get('b')).toBeNull();
+    expect(await storage.keys()).toEqual([]);
+  });
+
+  it('keys returns all stored keys', async () => {
+    await storage.set('alpha', 1);
+    await storage.set('beta', 2);
+    const keys = await storage.keys();
+    expect(keys.sort()).toEqual(['alpha', 'beta']);
+  });
+
+  it('stores binary data (ArrayBuffer)', async () => {
+    const buffer = new Uint8Array([1, 2, 3, 4]).buffer;
+    await storage.set('binary', buffer);
+    const result = await storage.get<ArrayBuffer>('binary');
+    expect(result).toBeInstanceOf(ArrayBuffer);
+    expect(new Uint8Array(result!)).toEqual(new Uint8Array([1, 2, 3, 4]));
+  });
+
+  it('stores Uint8Array', async () => {
+    const data = new Uint8Array([10, 20, 30]);
+    await storage.set('bytes', data);
+    const result = await storage.get<Uint8Array>('bytes');
+    expect(new Uint8Array(result!)).toEqual(new Uint8Array([10, 20, 30]));
+  });
+});
+
+describe('LocalForageAdapter with prefix', () => {
+  let storage: LocalForageAdapter;
+
+  beforeEach(async () => {
+    storage = new LocalForageAdapter({
+      name: 'test-db-prefix',
+      storeName: 'test-store',
+      prefix: 'slot1:',
+    });
+    await storage.clear();
+  });
+
+  it('get/set respects prefix', async () => {
+    await storage.set('doc', { title: 'My Doc' });
+    expect(await storage.get('doc')).toEqual({ title: 'My Doc' });
+  });
+
+  it('keys strips prefix', async () => {
+    await storage.set('alpha', 1);
+    await storage.set('beta', 2);
+    const keys = await storage.keys();
+    expect(keys.sort()).toEqual(['alpha', 'beta']);
+  });
+
+  it('clear only removes prefixed keys', async () => {
+    // Write directly to a separate adapter (no prefix) to verify isolation
+    const other = new LocalForageAdapter({
+      name: 'test-db-prefix',
+      storeName: 'test-store',
+      prefix: 'slot2:',
+    });
+    await other.set('other-key', 'should-survive');
+    await storage.set('my-key', 'will-be-cleared');
+
+    await storage.clear();
+
+    expect(await storage.get('my-key')).toBeNull();
+    expect(await other.get('other-key')).toBe('should-survive');
+
+    // Cleanup
+    await other.clear();
+  });
+
+  it('different prefixes are isolated', async () => {
+    const slot1 = new LocalForageAdapter({
+      name: 'test-isolation',
+      storeName: 'test-store',
+      prefix: 'slot1:',
+    });
+    const slot2 = new LocalForageAdapter({
+      name: 'test-isolation',
+      storeName: 'test-store',
+      prefix: 'slot2:',
+    });
+
+    await slot1.set('doc', 'slot1-doc');
+    await slot2.set('doc', 'slot2-doc');
+
+    expect(await slot1.get('doc')).toBe('slot1-doc');
+    expect(await slot2.get('doc')).toBe('slot2-doc');
+
+    const keys1 = await slot1.keys();
+    const keys2 = await slot2.keys();
+    expect(keys1).toEqual(['doc']);
+    expect(keys2).toEqual(['doc']);
+
+    // Cleanup
+    await slot1.clear();
+    await slot2.clear();
+  });
+});