@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/imageEditVersions.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryContentContainer } from '../storage/ContentContainer';
-import { scopeContainer } from '../storage/ScopedContentContainer';
-import { createEmptyImageEditDoc, addLayer } from '../imageEdit/state';
-import { writeImageEditDoc, readImageEditDoc } from '../imageEdit/persistence';
-import {
-  saveImageEditVersion,
-  listImageEditVersions,
-  readImageEditVersion,
-  revertToImageEditVersion,
-  pruneImageEditVersions,
-} from '../imageEdit/versions';
-import { ImageEditVersionManager } from '../imageEdit/ImageEditVersionManager';
-import type { ImageEditLayer } from '../schemas/ImageEditDoc';
-
-const text = (id: string): ImageEditLayer => ({
-  id,
-  type: 'text',
-  position: { x: 0, y: 0 },
-  content: { text: id, style: { fontSize: 16, color: '#000' } },
-});
-
-describe('imageEdit/persistence', () => {
-  it('round-trips state.json', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'image_files');
-    const doc = addLayer(createEmptyImageEditDoc(640, 480), text('a'));
-    await writeImageEditDoc(sidecar, doc);
-    const read = await readImageEditDoc(sidecar);
-    expect(read?.canvas.width).toBe(640);
-    expect(read?.layers).toHaveLength(1);
-    expect(read?.layers[0]!.id).toBe('a');
-  });
-
-  it('returns null when state.json is missing', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    expect(await readImageEditDoc(sidecar)).toBeNull();
-  });
-
-  it('rejects unsupported schema version', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await sidecar.writeFile(
-      'state.json',
-      new TextEncoder().encode(
-        JSON.stringify({ version: 2, canvas: { width: 1, height: 1 }, layers: [] }),
-      ),
-    );
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/unsupported schema version/);
-  });
-
-  async function writeRaw(sidecar: ReturnType<typeof scopeContainer>, payload: unknown) {
-    await sidecar.writeFile('state.json', new TextEncoder().encode(JSON.stringify(payload)));
-  }
-
-  it('rejects layer that is not an object', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, { version: 1, canvas: { width: 1, height: 1 }, layers: [null] });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/layers\[0\] must be an object/);
-  });
-
-  it('rejects layer with missing id', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ type: 'text', position: { x: 0, y: 0 }, content: { text: 'hi', style: {} } }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/must have a string id/);
-  });
-
-  it('rejects layer with invalid type', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ id: 'x', type: 'video', position: { x: 0, y: 0 }, content: {} }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(
-      /type must be one of image\|text\|shape/,
-    );
-  });
-
-  it('rejects image layer with missing content.src', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ id: 'x', type: 'image', position: { x: 0, y: 0 }, content: { alt: 'test' } }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/content\.src must be a string/);
-  });
-
-  it('rejects text layer with missing content.text', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ id: 'x', type: 'text', position: { x: 0, y: 0 }, content: { style: {} } }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/content\.text must be a string/);
-  });
-
-  it('rejects shape layer with missing content.shape', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ id: 'x', type: 'shape', position: { x: 0, y: 0 }, content: {} }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/content\.shape must be a string/);
-  });
-
-  it('rejects layer with missing position', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'sc');
-    await writeRaw(sidecar, {
-      version: 1,
-      canvas: { width: 1, height: 1 },
-      layers: [{ id: 'x', type: 'shape', content: { shape: 'rect' } }],
-    });
-    await expect(readImageEditDoc(sidecar)).rejects.toThrow(/position must have/);
-  });
-});
-
-describe('imageEdit/versions', () => {
-  let parent: MemoryContentContainer;
-  let sidecar: ReturnType<typeof scopeContainer>;
-
-  beforeEach(() => {
-    parent = new MemoryContentContainer();
-    sidecar = scopeContainer(parent, 'image_files');
-  });
-
-  it('saves a snapshot when state.json exists', async () => {
-    const doc = addLayer(createEmptyImageEditDoc(100, 100), text('a'));
-    await writeImageEditDoc(sidecar, doc);
-    const result = await saveImageEditVersion(sidecar, { now: new Date('2026-04-01T10:00:00Z') });
-    expect(result.saved).toBe(true);
-    expect(result.version?.path).toMatch(/^\.versions\/state\.\d{8}T\d{6}Z\.json$/);
-    // snapshot is inside the sidecar, visible to the parent under the prefix
-    expect(await parent.exists(`image_files/${result.version!.path}`)).toBe(true);
-    const gitignore = await parent.readFile('image_files/.gitignore');
-    expect(gitignore && new TextDecoder().decode(gitignore)).toBe('.versions/\n');
-  });
-
-  it('returns no-state when sidecar is empty', async () => {
-    const result = await saveImageEditVersion(sidecar);
-    expect(result).toEqual({ saved: false, version: null, reason: 'no-state' });
-  });
-
-  it('skips saving when content is unchanged', async () => {
-    const doc = createEmptyImageEditDoc(100, 100, { now: new Date('2026-01-01') });
-    await writeImageEditDoc(sidecar, doc);
-    const first = await saveImageEditVersion(sidecar, {
-      doc,
-      now: new Date('2026-04-01T10:00:00Z'),
-    });
-    expect(first.saved).toBe(true);
-    const second = await saveImageEditVersion(sidecar, {
-      doc,
-      now: new Date('2026-04-01T10:01:00Z'),
-    });
-    expect(second).toEqual({ saved: false, version: null, reason: 'unchanged' });
-  });
-
-  it('appends a collision suffix when saves land in the same second', async () => {
-    const same = new Date('2026-04-01T10:00:00Z');
-    const docA = addLayer(createEmptyImageEditDoc(100, 100), text('a'));
-    const docB = addLayer(createEmptyImageEditDoc(100, 100), text('b'));
-    const r1 = await saveImageEditVersion(sidecar, { doc: docA, now: same });
-    const r2 = await saveImageEditVersion(sidecar, { doc: docB, now: same });
-    expect(r1.saved).toBe(true);
-    expect(r2.saved).toBe(true);
-    expect(r1.version!.path).not.toBe(r2.version!.path);
-    expect(r2.version!.path).toMatch(/-2\.json$/);
-  });
-
-  it('lists versions newest-first', async () => {
-    await saveImageEditVersion(sidecar, {
-      doc: addLayer(createEmptyImageEditDoc(100, 100), text('a')),
-      now: new Date('2026-01-01T00:00:00Z'),
-    });
-    await saveImageEditVersion(sidecar, {
-      doc: addLayer(createEmptyImageEditDoc(100, 100), text('b')),
-      now: new Date('2026-02-01T00:00:00Z'),
-    });
-    const versions = await listImageEditVersions(sidecar);
-    expect(versions).toHaveLength(2);
-    expect(versions[0]!.timestamp.getUTCFullYear()).toBe(2026);
-    expect(versions[0]!.timestamp.getUTCMonth()).toBe(1); // Feb
-  });
-
-  it('readImageEditVersion returns the parsed snapshot', async () => {
-    const doc = addLayer(createEmptyImageEditDoc(100, 100), text('a'));
-    const result = await saveImageEditVersion(sidecar, {
-      doc,
-      now: new Date('2026-03-01T00:00:00Z'),
-    });
-    const read = await readImageEditVersion(sidecar, result.version!);
-    expect(read?.layers[0]!.id).toBe('a');
-  });
-
-  it('revertToImageEditVersion restores state.json and snapshots current first', async () => {
-    const docA = addLayer(createEmptyImageEditDoc(100, 100), text('a'));
-    await writeImageEditDoc(sidecar, docA);
-    const v1 = await saveImageEditVersion(sidecar, {
-      doc: docA,
-      now: new Date('2026-01-01T00:00:00Z'),
-    });
-
-    const docB = addLayer(createEmptyImageEditDoc(100, 100), text('b'));
-    await writeImageEditDoc(sidecar, docB);
-    const result = await revertToImageEditVersion(sidecar, v1.version!);
-
-    expect(result.reverted).toBe(true);
-    expect(result.snapshotted).not.toBeNull();
-    const current = await readImageEditDoc(sidecar);
-    expect(current?.layers[0]!.id).toBe('a');
-  });
-
-  it('pruneImageEditVersions keep-last-n drops older snapshots', async () => {
-    for (let i = 0; i < 5; i++) {
-      await saveImageEditVersion(sidecar, {
-        doc: addLayer(createEmptyImageEditDoc(100, 100), text(`v${i}`)),
-        now: new Date(`2026-01-0${i + 1}T00:00:00Z`),
-      });
-    }
-    const deleted = await pruneImageEditVersions(sidecar, { type: 'keep-last-n', n: 2 });
-    expect(deleted).toHaveLength(3);
-    const remaining = await listImageEditVersions(sidecar);
-    expect(remaining).toHaveLength(2);
-  });
-});
-
-describe('ImageEditVersionManager', () => {
-  it('mirrors operations against the captured container', async () => {
-    const sidecar = scopeContainer(new MemoryContentContainer(), 'image_files');
-    const mgr = new ImageEditVersionManager(sidecar);
-    const doc = addLayer(createEmptyImageEditDoc(100, 100), text('a'));
-    await writeImageEditDoc(sidecar, doc);
-    const r = await mgr.saveVersion({ now: new Date('2026-04-01T00:00:00Z') });
-    expect(r.saved).toBe(true);
-    expect((await mgr.listVersions())[0]!.path).toBe(r.version!.path);
-  });
-});

package/src/__tests__/inferDocumentTitle.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { inferDocumentTitle } from '../markdown/utils.js';
-
-describe('inferDocumentTitle', () => {
-  it('returns the frontmatter title when set', () => {
-    const doc = parseMarkdown('---\ntitle: My Doc\n---\n\n# Heading\n');
-    expect(inferDocumentTitle(doc)).toBe('My Doc');
-  });
-
-  it('trims surrounding whitespace from frontmatter title', () => {
-    const doc = parseMarkdown('---\ntitle: "  Spaced  "\n---\n\n# Heading\n');
-    expect(inferDocumentTitle(doc)).toBe('Spaced');
-  });
-
-  it('falls back to the first H1 when frontmatter title is absent', () => {
-    const doc = parseMarkdown('# Welcome\n\n## Details');
-    expect(inferDocumentTitle(doc)).toBe('Welcome');
-  });
-
-  it('falls back to the first H2 when no H1 is present', () => {
-    const doc = parseMarkdown('## Section\n\n### Detail');
-    expect(inferDocumentTitle(doc)).toBe('Section');
-  });
-
-  it('prefers the shallowest heading regardless of source order', () => {
-    const doc = parseMarkdown('## Earlier H2\n\n# Real Title\n\n### Nested');
-    expect(inferDocumentTitle(doc)).toBe('Real Title');
-  });
-
-  it('skips empty frontmatter title and falls back to headings', () => {
-    const doc = parseMarkdown('---\ntitle: ""\n---\n\n# Real\n');
-    expect(inferDocumentTitle(doc)).toBe('Real');
-  });
-
-  it('returns undefined when there is no frontmatter and no heading', () => {
-    const doc = parseMarkdown('Just a paragraph.\n\nAnother one.');
-    expect(inferDocumentTitle(doc)).toBeUndefined();
-  });
-
-  it('strips inline formatting from heading text', () => {
-    const doc = parseMarkdown('# **Bold** and *italic*');
-    expect(inferDocumentTitle(doc)).toBe('Bold and italic');
-  });
-
-  it('skips headings that contain only whitespace', () => {
-    const doc = parseMarkdown('#  \n\n## Real Heading');
-    expect(inferDocumentTitle(doc)).toBe('Real Heading');
-  });
-});

package/src/__tests__/inlineIconMarker.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  hasIconMarker,
-  iconClass,
-  iconMarker,
-  splitIconMarkers,
-  stripIconMarkers,
-} from '../icons/inlineIconMarker';
-
-describe('inline icon markers', () => {
-  it('encodes icons with a private-use sentinel', () => {
-    expect(iconMarker('solid', 'rocket')).toBe('\uE000solid:rocket\uE000');
-  });
-
-  it('detects and strips encoded markers from plain-text projections', () => {
-    const text = `Launch ${iconMarker('solid', 'rocket')} now`;
-
-    expect(hasIconMarker(text)).toBe(true);
-    expect(stripIconMarkers(text)).toBe('Launch  now');
-  });
-
-  it('splits marker-bearing text into text and icon runs', () => {
-    const text = `A ${iconMarker('regular', 'star')} and ${iconMarker('brands', 'github')}`;
-
-    expect(splitIconMarkers(text)).toEqual([
-      { type: 'text', text: 'A ' },
-      { type: 'icon', family: 'regular', name: 'star' },
-      { type: 'text', text: ' and ' },
-      { type: 'icon', family: 'brands', name: 'github' },
-    ]);
-  });
-
-  it('builds FontAwesome class names', () => {
-    expect(iconClass('solid', 'rocket')).toBe('fa-solid fa-rocket');
-  });
-});

package/src/__tests__/inputDescriptors.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  BASE_INPUT_DESCRIPTORS,
-  TEMPLATE_INPUT_DESCRIPTORS,
-  coerceTemplateParams,
-  lintTemplateParams,
-} from '../doc/templates/inputDescriptors';
-import { templateRegistry } from '../doc/templates/index';
-
-describe('coerceTemplateParams', () => {
-  it('coerces number keys, leaving the raw string on failure', () => {
-    expect(coerceTemplateParams('map', { zoom: '9' }).input).toEqual({ zoom: 9 });
-
-    const bad = coerceTemplateParams('map', { zoom: 'abc' });
-    expect(bad.input).toEqual({ zoom: 'abc' });
-    expect(bad.warnings).toHaveLength(1);
-    expect(bad.warnings[0]).toContain('zoom');
-  });
-
-  it('coerces boolean keys (true/empty → true, false → false)', () => {
-    const { input } = coerceTemplateParams('imageWithCaption', { isTitle: 'true' });
-    expect(input.isTitle).toBe(true);
-    // A bare flag `{[… isTitle]}` parses to an empty value → true.
-    expect(coerceTemplateParams('imageWithCaption', { isTitle: '' }).input.isTitle).toBe(true);
-    expect(coerceTemplateParams('imageWithCaption', { isTitle: 'false' }).input.isTitle).toBe(
-      false,
-    );
-
-    const bad = coerceTemplateParams('imageWithCaption', { isTitle: 'maybe' });
-    expect(bad.input.isTitle).toBe('maybe');
-    expect(bad.warnings).toHaveLength(1);
-  });
-
-  it('coerces latLng into { lat, lng }, warning on malformed input', () => {
-    expect(coerceTemplateParams('map', { center: '47.6,-122.3' }).input).toEqual({
-      center: { lat: 47.6, lng: -122.3 },
-    });
-
-    const bad = coerceTemplateParams('map', { center: 'nope' });
-    expect(bad.input).toEqual({ center: 'nope' });
-    expect(bad.warnings[0]).toContain('center');
-  });
-
-  it('coerces labeledPair into { label, sublabel? }', () => {
-    expect(coerceTemplateParams('twoColumn', { left: 'Espresso|Bold' }).input).toEqual({
-      left: { label: 'Espresso', sublabel: 'Bold' },
-    });
-    // No separator → label only, no sublabel key.
-    expect(coerceTemplateParams('twoColumn', { right: 'Filter' }).input).toEqual({
-      right: { label: 'Filter' },
-    });
-  });
-
-  it('coerces stringList by splitting on commas and trimming', () => {
-    expect(coerceTemplateParams('photoGrid', { images: 'a.jpg, b.jpg ,c.jpg' }).input).toEqual({
-      images: ['a.jpg', 'b.jpg', 'c.jpg'],
-    });
-  });
-
-  it('passes unknown keys through unchanged as strings (never lossy)', () => {
-    const { input, warnings } = coerceTemplateParams('map', { wobble: 'yes', center: '1,2' });
-    expect(input.wobble).toBe('yes');
-    expect(input.center).toEqual({ lat: 1, lng: 2 });
-    expect(warnings).toEqual([]);
-  });
-
-  it('passes everything through for a template with no descriptors', () => {
-    expect(coerceTemplateParams('sectionHeader', { anything: '5' }).input).toEqual({
-      anything: '5',
-    });
-  });
-
-  it('resolves legacy template aliases before coercing', () => {
-    expect(coerceTemplateParams('mapBlock', { zoom: '7' }).input).toEqual({ zoom: 7 });
-  });
-
-  it('coerces shared base inputs (useTopLayer boolean)', () => {
-    expect(coerceTemplateParams('title', { useTopLayer: 'false' }).input.useTopLayer).toBe(false);
-  });
-});
-
-describe('lintTemplateParams', () => {
-  it('returns [] for a template without descriptors', () => {
-    expect(lintTemplateParams('sectionHeader', { foo: 'bar' })).toEqual([]);
-  });
-
-  it('flags an unknown input with a did-you-mean suggestion', () => {
-    const findings = lintTemplateParams('map', { centre: '1,2' });
-    const unknown = findings.find((f) => f.kind === 'unknown-input');
-    expect(unknown).toBeDefined();
-    expect(unknown!.key).toBe('centre');
-    expect(unknown!.suggestion).toBe('center');
-    expect(unknown!.message).toContain('Did you mean "center"?');
-  });
-
-  it('does not flag block-meta keys carried on the same annotation', () => {
-    const findings = lintTemplateParams('title', { duration: '8', transition: 'fade' });
-    expect(findings.filter((f) => f.kind === 'unknown-input')).toEqual([]);
-  });
-
-  it('flags a value outside a closed enum', () => {
-    const findings = lintTemplateParams('map', { center: '1,2', mapStyle: 'nope' });
-    const invalid = findings.find((f) => f.kind === 'invalid-input-value');
-    expect(invalid).toBeDefined();
-    expect(invalid!.key).toBe('mapStyle');
-    expect(invalid!.message).toContain('terrain');
-  });
-
-  it('flags a value that fails coercion (bad latLng)', () => {
-    const findings = lintTemplateParams('map', { center: 'garbage' });
-    expect(findings.some((f) => f.kind === 'invalid-input-value' && f.key === 'center')).toBe(true);
-  });
-
-  it('flags missing required inputs', () => {
-    const findings = lintTemplateParams('twoColumn', {});
-    const missing = findings
-      .filter((f) => f.kind === 'missing-input')
-      .map((f) => f.key)
-      .sort();
-    expect(missing).toEqual(['left', 'right']);
-  });
-
-  it('does not flag a required input that is present', () => {
-    const findings = lintTemplateParams('map', { center: '1,2' });
-    expect(findings.filter((f) => f.kind === 'missing-input')).toEqual([]);
-  });
-
-  it('accepts a valid enum value', () => {
-    const findings = lintTemplateParams('map', { center: '1,2', mapStyle: 'satellite' });
-    expect(findings).toEqual([]);
-  });
-});
-
-describe('descriptor registry shape', () => {
-  it('base descriptors are declared with unique keys', () => {
-    const keys = BASE_INPUT_DESCRIPTORS.map((d) => d.key);
-    expect(new Set(keys).size).toBe(keys.length);
-  });
-
-  it('has no orphan descriptors — every keyed template exists in the registry', () => {
-    for (const template of Object.keys(TEMPLATE_INPUT_DESCRIPTORS)) {
-      expect(templateRegistry, `orphan descriptor for "${template}"`).toHaveProperty(template);
-    }
-  });
-
-  it('every template descriptor has unique keys and a description', () => {
-    for (const [template, descriptors] of Object.entries(TEMPLATE_INPUT_DESCRIPTORS)) {
-      const keys = descriptors.map((d) => d.key);
-      expect(new Set(keys).size, `duplicate key in ${template}`).toBe(keys.length);
-      for (const d of descriptors) {
-        expect(d.description.length, `empty description for ${template}.${d.key}`).toBeGreaterThan(
-          0,
-        );
-        // values / valueHint are mutually exclusive.
-        expect(
-          !(d.values && d.valueHint),
-          `${template}.${d.key} has both values and valueHint`,
-        ).toBe(true);
-      }
-    }
-  });
-});

package/src/__tests__/jsonForm.chooseControl.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { chooseControl, primaryType, arrayItemKind } from '../jsonForm/index.js';
-
-describe('chooseControl', () => {
-  it('honors explicit squisq.control', () => {
-    expect(chooseControl({ type: 'string', squisq: { control: 'radio' } })).toBe('radio');
-  });
-
-  it('maps format=color', () => {
-    expect(chooseControl({ type: 'string', format: 'color' })).toBe('color');
-  });
-  it('maps format=date / time / date-time / markdown / textarea', () => {
-    expect(chooseControl({ type: 'string', format: 'date' })).toBe('date');
-    expect(chooseControl({ type: 'string', format: 'time' })).toBe('time');
-    expect(chooseControl({ type: 'string', format: 'date-time' })).toBe('datetime');
-    expect(chooseControl({ type: 'string', format: 'markdown' })).toBe('richtext');
-    expect(chooseControl({ type: 'string', format: 'textarea' })).toBe('multiline');
-  });
-
-  it('uses segmented for short enums (≤4)', () => {
-    expect(chooseControl({ type: 'string', enum: ['a', 'b', 'c'] })).toBe('segmented');
-    expect(chooseControl({ type: 'string', enum: ['a', 'b', 'c', 'd'] })).toBe('segmented');
-  });
-  it('uses combobox for long enums (>4)', () => {
-    expect(chooseControl({ type: 'string', enum: ['a', 'b', 'c', 'd', 'e'] })).toBe('combobox');
-  });
-
-  it('arrays of objects → card-stack', () => {
-    expect(chooseControl({ type: 'array', items: { type: 'object', properties: {} } })).toBe(
-      'card-stack',
-    );
-  });
-  it('arrays of primitives → chip-bin', () => {
-    expect(chooseControl({ type: 'array', items: { type: 'string' } })).toBe('chip-bin');
-  });
-
-  it('booleans → toggle', () => {
-    expect(chooseControl({ type: 'boolean' })).toBe('toggle');
-  });
-
-  it('numbers with both min and max → slider', () => {
-    expect(chooseControl({ type: 'number', minimum: 0, maximum: 100 })).toBe('slider');
-  });
-  it('numbers without bounded range → stepper', () => {
-    expect(chooseControl({ type: 'number' })).toBe('stepper');
-    expect(chooseControl({ type: 'integer', minimum: 0 })).toBe('stepper');
-  });
-
-  it('strings with maxLength > 200 → multiline', () => {
-    expect(chooseControl({ type: 'string', maxLength: 500 })).toBe('multiline');
-  });
-  it('plain strings → text', () => {
-    expect(chooseControl({ type: 'string' })).toBe('text');
-  });
-
-  it('objects → group', () => {
-    expect(chooseControl({ type: 'object', properties: {} })).toBe('group');
-  });
-
-  it('oneOf / anyOf → tabs', () => {
-    expect(chooseControl({ oneOf: [{ type: 'string' }, { type: 'number' }] })).toBe('tabs');
-    expect(chooseControl({ anyOf: [{ type: 'string' }, { type: 'number' }] })).toBe('tabs');
-  });
-});
-
-describe('primaryType', () => {
-  it('returns the lone type', () => {
-    expect(primaryType({ type: 'string' })).toBe('string');
-  });
-  it('skips null in nullable shorthand', () => {
-    expect(primaryType({ type: ['string', 'null'] })).toBe('string');
-    expect(primaryType({ type: ['null', 'integer'] })).toBe('integer');
-  });
-});
-
-describe('arrayItemKind', () => {
-  it('detects object items', () => {
-    expect(arrayItemKind({ type: 'array', items: { type: 'object' } })).toBe('object');
-  });
-  it('detects primitive items', () => {
-    expect(arrayItemKind({ type: 'array', items: { type: 'string' } })).toBe('primitive');
-  });
-  it('treats missing items as primitive', () => {
-    expect(arrayItemKind({ type: 'array' })).toBe('primitive');
-  });
-});

package/src/__tests__/jsonForm.evaluateWhen.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { evaluateWhen, resolveFlag } from '../jsonForm/index.js';
-
-const data = {
-  user: { role: 'admin', name: 'Alex' },
-  count: 3,
-  active: true,
-  tags: ['a', 'b'],
-};
-
-describe('evaluateWhen', () => {
-  it('equals — primitives', () => {
-    expect(evaluateWhen({ field: 'user.role', equals: 'admin' }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'user.role', equals: 'guest' }, data)).toBe(false);
-  });
-
-  it('equals — arrays via deep equality', () => {
-    expect(evaluateWhen({ field: 'tags', equals: ['a', 'b'] }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'tags', equals: ['a'] }, data)).toBe(false);
-  });
-
-  it('oneOf', () => {
-    expect(evaluateWhen({ field: 'count', oneOf: [1, 2, 3] }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'count', oneOf: [10, 20] }, data)).toBe(false);
-  });
-
-  it('matches regex', () => {
-    expect(evaluateWhen({ field: 'user.name', matches: '^Al' }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'user.name', matches: '^Bo' }, data)).toBe(false);
-  });
-
-  it('matches: returns false for non-string targets', () => {
-    expect(evaluateWhen({ field: 'count', matches: '\\d' }, data)).toBe(false);
-  });
-
-  it('truthy', () => {
-    expect(evaluateWhen({ field: 'active', truthy: true }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'active', truthy: false }, data)).toBe(false);
-    expect(evaluateWhen({ field: 'missing', truthy: false }, data)).toBe(true);
-  });
-
-  it('default behavior with no operator: field is defined', () => {
-    expect(evaluateWhen({ field: 'count' }, data)).toBe(true);
-    expect(evaluateWhen({ field: 'missing' }, data)).toBe(false);
-  });
-});
-
-describe('resolveFlag', () => {
-  it('passes through literal booleans', () => {
-    expect(resolveFlag(true, data)).toBe(true);
-    expect(resolveFlag(false, data)).toBe(false);
-  });
-  it('returns false for undefined', () => {
-    expect(resolveFlag(undefined, data)).toBe(false);
-  });
-  it('evaluates SquisqWhen', () => {
-    expect(resolveFlag({ field: 'user.role', equals: 'admin' }, data)).toBe(true);
-  });
-});

package/src/__tests__/jsonForm.inferSchema.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { inferSchema } from '../jsonForm/index.js';
-
-describe('inferSchema', () => {
-  it('infers an object schema from a sample', () => {
-    const schema = inferSchema({ name: 'Alex', age: 30, active: true });
-    expect(schema.type).toBe('object');
-    expect(schema.properties?.name?.type).toBe('string');
-    expect(schema.properties?.age?.type).toBe('integer');
-    expect(schema.properties?.active?.type).toBe('boolean');
-  });
-
-  it('infers array item types', () => {
-    const schema = inferSchema({ tags: ['a', 'b', 'c'] });
-    const items = schema.properties?.tags?.items;
-    const first = Array.isArray(items) ? items[0] : items;
-    expect(first?.type).toBe('string');
-  });
-
-  it('merges multiple samples', () => {
-    const schema = inferSchema({ name: 'Alex' }, { additionalSamples: [{ name: 'Bo', age: 5 }] });
-    expect(schema.properties?.name?.type).toBe('string');
-    expect(schema.properties?.age?.type).toBe('integer');
-  });
-});