@bendyline/squisq 1.3.0 → 1.4.1

package/src/__tests__/iconResolve.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveIcon,
+  canonicalIconToken,
+  looksLikeIconToken,
+  suggestIcons,
+} from '../icons/resolve';
+
+describe('resolveIcon — bare tokens', () => {
+  it('resolves a name that is unique across families', () => {
+    // `github` only exists in fa-brands.
+    const icon = resolveIcon('github');
+    expect(icon).not.toBeNull();
+    expect(icon!.family).toBe('brands');
+    expect(icon!.name).toBe('github');
+  });
+
+  it('returns null for a name that collides across families', () => {
+    // `user` ships in both solid and regular — bare form is ambiguous.
+    const icon = resolveIcon('user');
+    expect(icon).toBeNull();
+  });
+
+  it('returns null for unknown names', () => {
+    expect(resolveIcon('totallyMadeUp_____Name')).toBeNull();
+  });
+});
+
+describe('resolveIcon — qualified tokens', () => {
+  it('resolves an ambiguous name with the fa-solid: prefix', () => {
+    const icon = resolveIcon('fa-solid:user');
+    expect(icon).not.toBeNull();
+    expect(icon!.family).toBe('solid');
+    expect(icon!.name).toBe('user');
+  });
+
+  it('resolves the same name in the other family', () => {
+    const icon = resolveIcon('fa-regular:user');
+    expect(icon).not.toBeNull();
+    expect(icon!.family).toBe('regular');
+  });
+
+  it('accepts short family prefixes too', () => {
+    const icon = resolveIcon('brands:github');
+    expect(icon).not.toBeNull();
+    expect(icon!.family).toBe('brands');
+  });
+
+  it('returns null for an unknown family prefix', () => {
+    expect(resolveIcon('fa-foo:github')).toBeNull();
+  });
+
+  it('returns null for a qualified token whose name does not exist in that family', () => {
+    expect(resolveIcon('fa-brands:user')).toBeNull();
+  });
+});
+
+describe('canonicalIconToken', () => {
+  it('emits the bare form for unique names', () => {
+    const icon = resolveIcon('github')!;
+    expect(canonicalIconToken(icon)).toBe('github');
+  });
+
+  it('emits the qualified form for ambiguous names', () => {
+    const icon = resolveIcon('fa-solid:user')!;
+    expect(canonicalIconToken(icon)).toBe('fa-solid:user');
+  });
+});
+
+describe('suggestIcons', () => {
+  it('ranks "starts with" matches above "contains" matches', () => {
+    const results = suggestIcons('git');
+    // `github` (brands) starts with "git" → score 0; `digital-tachograph`
+    // contains "git" → score 1. The first must outrank the latter.
+    const githubIdx = results.findIndex((r) => r.entry.name === 'github');
+    const containsIdx = results.findIndex(
+      (r) => r.entry.name.includes('git') && !r.entry.name.startsWith('git'),
+    );
+    expect(githubIdx).toBeGreaterThanOrEqual(0);
+    if (containsIdx >= 0) {
+      expect(githubIdx).toBeLessThan(containsIdx);
+    }
+  });
+
+  it('returns canonical tokens (bare when unique, qualified otherwise)', () => {
+    const results = suggestIcons('user');
+    const userTokens = results.filter((r) => r.entry.name === 'user').map((r) => r.token);
+    // `user` is ambiguous — each match must be qualified.
+    expect(userTokens.every((t) => t.startsWith('fa-'))).toBe(true);
+  });
+
+  it('matches by keyword too', () => {
+    const results = suggestIcons('octocat'); // a github keyword
+    expect(results.some((r) => r.entry.name === 'github')).toBe(true);
+  });
+
+  it('honors the limit parameter', () => {
+    expect(suggestIcons('e', 5)).toHaveLength(5);
+  });
+
+  it('returns nothing useful for whitespace-only queries', () => {
+    // Empty / whitespace queries return the first N icons (score 3
+    // bucket) — useful as a "browse the catalog" affordance in pickers.
+    const results = suggestIcons('   ', 10);
+    expect(results).toHaveLength(10);
+    expect(results.every((r) => r.score === 3)).toBe(true);
+  });
+});
+
+describe('looksLikeIconToken', () => {
+  it('accepts alphanumeric tokens with hyphens, underscores, and one colon', () => {
+    expect(looksLikeIconToken('github')).toBe(true);
+    expect(looksLikeIconToken('fa-solid:user')).toBe(true);
+    expect(looksLikeIconToken('face-smile_wink')).toBe(true);
+  });
+
+  it('rejects whitespace and special characters', () => {
+    expect(looksLikeIconToken('hello world')).toBe(false);
+    expect(looksLikeIconToken('with/slash')).toBe(false);
+    expect(looksLikeIconToken('with$dollar')).toBe(false);
+  });
+});

package/src/__tests__/imageEditState.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createEmptyImageEditDoc,
+  addLayer,
+  removeLayer,
+  reorderLayer,
+  updateLayer,
+  setCanvas,
+} from '../imageEdit/state';
+import type { ImageEditLayer } from '../schemas/ImageEditDoc';
+
+function textLayer(id: string, text = 'hi'): ImageEditLayer {
+  return {
+    id,
+    type: 'text',
+    position: { x: 0, y: 0, width: 100, height: 30 },
+    content: { text, style: { fontSize: 16, color: '#000' } },
+  };
+}
+
+describe('imageEdit/state helpers', () => {
+  it('createEmptyImageEditDoc seeds canvas + meta', () => {
+    const doc = createEmptyImageEditDoc(800, 600, { sourcePath: 'src.png' });
+    expect(doc.version).toBe(1);
+    expect(doc.canvas).toEqual({ width: 800, height: 600, background: 'transparent' });
+    expect(doc.layers).toEqual([]);
+    expect(doc.meta?.sourcePath).toBe('src.png');
+    expect(doc.meta?.createdAt).toBeDefined();
+    expect(doc.meta?.updatedAt).toBeDefined();
+  });
+
+  it('addLayer appends and assigns id when missing', () => {
+    let doc = createEmptyImageEditDoc(100, 100);
+    doc = addLayer(doc, textLayer('a'));
+    doc = addLayer(doc, { ...textLayer(''), id: '' });
+    expect(doc.layers).toHaveLength(2);
+    expect(doc.layers[0]!.id).toBe('a');
+    expect(doc.layers[1]!.id).toMatch(/^layer-/);
+  });
+
+  it('removeLayer drops by id, no-op when missing', () => {
+    let doc = addLayer(createEmptyImageEditDoc(100, 100), textLayer('a'));
+    doc = addLayer(doc, textLayer('b'));
+    const after = removeLayer(doc, 'a');
+    expect(after.layers.map((l) => l.id)).toEqual(['b']);
+    const noop = removeLayer(after, 'missing');
+    expect(noop).toBe(after);
+  });
+
+  it('reorderLayer moves and clamps index', () => {
+    let doc = createEmptyImageEditDoc(100, 100);
+    for (const id of ['a', 'b', 'c']) doc = addLayer(doc, textLayer(id));
+    const moved = reorderLayer(doc, 'a', 99);
+    expect(moved.layers.map((l) => l.id)).toEqual(['b', 'c', 'a']);
+    const moved2 = reorderLayer(moved, 'a', -10);
+    expect(moved2.layers.map((l) => l.id)).toEqual(['a', 'b', 'c']);
+  });
+
+  it('updateLayer shallow-merges by id', () => {
+    let doc = addLayer(createEmptyImageEditDoc(100, 100), textLayer('a'));
+    doc = updateLayer(doc, 'a', { name: 'Title', opacity: 0.5 });
+    expect(doc.layers[0]!.name).toBe('Title');
+    expect(doc.layers[0]!.opacity).toBe(0.5);
+  });
+
+  it('setCanvas replaces canvas', () => {
+    const doc = setCanvas(createEmptyImageEditDoc(100, 100), {
+      width: 200,
+      height: 300,
+      background: '#fff',
+    });
+    expect(doc.canvas).toEqual({ width: 200, height: 300, background: '#fff' });
+  });
+});

package/src/__tests__/imageEditVersions.test.ts

@@ -0,0 +1,169 @@
+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/);
+  });
+});
+
+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);
+  });
+
+  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

@@ -0,0 +1,50 @@
+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__/jsonForm.chooseControl.test.ts

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,25 @@
+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');
+  });
+});