@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/draw/test/animate.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  type CubicBezierHandles,
-  easeBezier,
-  LINEAR,
-  lerpValue,
-  lerpVertices,
-  parallel,
-  resolveStagger,
-  sampleTrack,
-  sequence,
-  shiftTrack,
-  stagger,
-  type Track,
-  timeline,
-  track,
-  trackSpan,
-} from '../animate.ts';
-
-describe('easeBezier', () => {
-  test('linear is the identity', () => {
-    for (const x of [0, 0.25, 0.5, 0.75, 1]) {
-      expect(easeBezier(LINEAR, x)).toBeCloseTo(x, 6);
-    }
-  });
-  test('clamps the endpoints exactly', () => {
-    const e: CubicBezierHandles = [0.42, 0, 0.58, 1];
-    expect(easeBezier(e, 0)).toBe(0);
-    expect(easeBezier(e, 1)).toBe(1);
-    expect(easeBezier(e, -0.5)).toBe(0);
-    expect(easeBezier(e, 1.5)).toBe(1);
-  });
-  test('ease-in-out is symmetric about the midpoint and monotone', () => {
-    const e: CubicBezierHandles = [0.42, 0, 0.58, 1];
-    expect(easeBezier(e, 0.5)).toBeCloseTo(0.5, 4);
-    let prev = -1;
-    for (let i = 0; i <= 20; i++) {
-      const y = easeBezier(e, i / 20);
-      expect(y).toBeGreaterThanOrEqual(prev - 1e-9);
-      prev = y;
-    }
-  });
-  test('preserves overshoot (y > 1) for a snap easing', () => {
-    const snap: CubicBezierHandles = [0.34, 1.42, 0.64, 1];
-    let maxY = 0;
-    for (let i = 0; i <= 100; i++) maxY = Math.max(maxY, easeBezier(snap, i / 100));
-    expect(maxY).toBeGreaterThan(1); // the overshoot the snap depends on
-  });
-  test('round-trips a known x→t→y solve (ease-out)', () => {
-    // cubic-bezier(0,0,0.58,1): solving x then evaluating y must land in (x,1).
-    const e: CubicBezierHandles = [0, 0, 0.58, 1];
-    const y = easeBezier(e, 0.5);
-    expect(y).toBeGreaterThan(0.5); // ease-out is ahead of linear at the midpoint
-    expect(y).toBeLessThan(1);
-  });
-});
-
-describe('lerpValue / lerpVertices', () => {
-  test('numbers lerp', () => {
-    expect(lerpValue(0, 10, 0.3)).toBeCloseTo(3, 6);
-  });
-  test('number arrays lerp element-wise', () => {
-    expect(lerpValue([0, 10], [10, 0], 0.5)).toEqual([5, 5]);
-  });
-  test('vertex arrays lerp by component', () => {
-    const out = lerpVertices([{ x: 0, y: 0 }], [{ x: 4, y: 8 }], 0.25);
-    expect(out).toEqual([{ x: 1, y: 2 }]);
-  });
-  test('strings are a discrete hold (no interpolation)', () => {
-    expect(lerpValue('rotate(0)', 'rotate(90)', 0.5)).toBe('rotate(0)');
-    expect(lerpValue('rotate(0)', 'rotate(90)', 1)).toBe('rotate(90)');
-  });
-  test('vertex count mismatch throws (interpolability constraint)', () => {
-    expect(() => lerpVertices([{ x: 0, y: 0 }], [], 0.5)).toThrow(/vertex count mismatch/);
-  });
-});
-
-describe('sampleTrack', () => {
-  const tr = track('opacity', [
-    { t: 0, value: 0, ease: LINEAR },
-    { t: 1, value: 1 },
-  ]);
-  test('holds before the first and after the last keyframe', () => {
-    expect(sampleTrack(tr, -1)).toBe(0);
-    expect(sampleTrack(tr, 5)).toBe(1);
-  });
-  test('linear interpolation mid-segment', () => {
-    expect(sampleTrack(tr, 0.5)).toBeCloseTo(0.5, 6);
-  });
-  test('applies the leading keyframe easing', () => {
-    const eased = track('opacity', [
-      { t: 0, value: 0, ease: [0, 0, 0.58, 1] }, // ease-out
-      { t: 1, value: 1 },
-    ]);
-    expect(sampleTrack(eased, 0.5) as number).toBeGreaterThan(0.5);
-  });
-  test('empty track samples undefined', () => {
-    expect(sampleTrack(track('opacity', []), 0)).toBeUndefined();
-  });
-});
-
-describe('combinators', () => {
-  const a = (): Track =>
-    track(
-      'opacity',
-      [
-        { t: 0, value: 0 },
-        { t: 1, value: 1 },
-      ],
-      'a'
-    );
-  const b = (): Track =>
-    track(
-      'opacity',
-      [
-        { t: 0, value: 1 },
-        { t: 2, value: 0 },
-      ],
-      'b'
-    );
-
-  test('trackSpan is the latest keyframe time', () => {
-    expect(trackSpan([a(), b()])).toBe(2);
-  });
-
-  test('shiftTrack offsets every keyframe', () => {
-    const s = shiftTrack(a(), 3);
-    expect(s.keyframes.map((k) => k.t)).toEqual([3, 4]);
-    expect(a().keyframes[0].t).toBe(0); // immutable
-  });
-
-  test('stagger offsets track i by i·delay', () => {
-    const out = stagger([a(), b(), a()], 0.5);
-    expect(out[0].keyframes[0].t).toBe(0);
-    expect(out[1].keyframes[0].t).toBe(0.5);
-    expect(out[2].keyframes[0].t).toBe(1);
-  });
-
-  test('resolveStagger bakes the declarative field and grows dur', () => {
-    const tl = timeline({ tracks: [a(), b()], dur: 2, stagger: 0.5 });
-    const r = resolveStagger(tl);
-    expect(r.stagger).toBeUndefined();
-    expect(r.tracks[1].keyframes[0].t).toBe(0.5);
-    expect(r.dur).toBe(2.5); // b ended at 2 → shifted to 2.5
-  });
-
-  test('parallel unions tracks and takes the max duration', () => {
-    const tl = parallel(
-      timeline({ tracks: [a()], dur: 1 }),
-      timeline({ tracks: [b()], dur: 2, begin: 0.5 })
-    );
-    expect(tl.tracks.length).toBe(2);
-    expect(tl.dur).toBe(2.5); // 0.5 begin + 2 dur
-    expect(tl.tracks[1].keyframes[0].t).toBe(0.5); // b shifted by its begin
-  });
-
-  test('sequence chains timelines end-to-start and sums durations', () => {
-    const tl = sequence(timeline({ tracks: [a()], dur: 1 }), timeline({ tracks: [b()], dur: 2 }));
-    expect(tl.dur).toBe(3);
-    expect(tl.tracks[0].keyframes.map((k) => k.t)).toEqual([0, 1]);
-    expect(tl.tracks[1].keyframes.map((k) => k.t)).toEqual([1, 3]); // shifted by first dur
-  });
-
-  test('sequence honors a per-timeline begin gap', () => {
-    const tl = sequence(
-      timeline({ tracks: [a()], dur: 1 }),
-      timeline({ tracks: [a()], dur: 1, begin: 0.5 })
-    );
-    expect(tl.tracks[1].keyframes[0].t).toBe(1.5); // 1 (cursor) + 0.5 (gap)
-    expect(tl.dur).toBe(2.5);
-  });
-});

package/apps/studio/draw/test/brush.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  brushStroke,
-  contourLines,
-  crossHatch,
-  engraveLines,
-  hatch,
-  roughenFilter,
-  scatterAlong,
-  stippleFill,
-} from '../brush.ts';
-import type { Point } from '../primitives.ts';
-import { circle } from '../primitives.ts';
-import { toSvg } from '../serialize.ts';
-
-const LINE: Point[] = [
-  { x: 10, y: 50 },
-  { x: 40, y: 20 },
-  { x: 70, y: 60 },
-  { x: 100, y: 40 },
-];
-
-describe('L1 roughenFilter', () => {
-  test('emits a feTurbulence → feDisplacementMap chain', () => {
-    const svg = toSvg([roughenFilter('rough', { scale: 6 })], { viewBox: '0 0 10 10' });
-    expect(svg).toContain('<filter id="rough"');
-    expect(svg).toContain('<feTurbulence');
-    expect(svg).toContain('<feDisplacementMap');
-    expect(svg).toContain('scale="6"');
-  });
-});
-
-describe('L2 brushStroke (variable width → filled outline)', () => {
-  test('is a closed filled path, not a stroke', () => {
-    const p = brushStroke(LINE, { width: 14, taper: 'both' }) as {
-      el: string;
-      d: string;
-      fill?: string;
-      stroke?: string;
-    };
-    expect(p.el).toBe('path');
-    expect(p.d.startsWith('M')).toBe(true);
-    expect(p.d).toContain('C'); // smoothed
-    expect(p.d.trimEnd().endsWith('Z')).toBe(true); // closed outline
-    expect(p.fill).toBe('currentColor'); // filled, default theme color
-    expect(p.stroke).toBeUndefined(); // NOT an svg stroke
-  });
-  test('taper "both" → pointed ends (start ≈ end ≈ centerline endpoints)', () => {
-    const p = brushStroke(LINE, { width: 20, taper: 'both' }) as { d: string };
-    // first move-to should be ~ the first centerline point (half-width ≈ 0 at t=0)
-    const m = /^M([-\d.]+) ([-\d.]+)/.exec(p.d);
-    expect(m).not.toBeNull();
-    const x0 = Number((m as RegExpExecArray)[1]);
-    const y0 = Number((m as RegExpExecArray)[2]);
-    expect(Math.hypot(x0 - 10, y0 - 50)).toBeLessThan(2);
-  });
-  test('a custom pressure profile is honored', () => {
-    const d1 = (brushStroke(LINE, { width: 16, profile: () => 1 }) as { d: string }).d;
-    const d2 = (brushStroke(LINE, { width: 16, profile: () => 0.2 }) as { d: string }).d;
-    expect(d1).not.toBe(d2); // thinner profile → different outline
-  });
-  test('deterministic', () => {
-    expect((brushStroke(LINE, { width: 12 }) as { d: string }).d).toBe(
-      (brushStroke(LINE, { width: 12 }) as { d: string }).d
-    );
-  });
-});
-
-describe('L3 scatterAlong (stamp along a path)', () => {
-  test('produces `count` stamped groups, deterministic for a seed', () => {
-    const make = () => circle({ cx: 0, cy: 0, r: 3, fill: '#333' });
-    const g1 = scatterAlong(LINE, make, { count: 8, jitter: 4, scaleVar: 0.3, seed: 5 }) as {
-      el: string;
-      children: unknown[];
-    };
-    expect(g1.el).toBe('group');
-    expect(g1.children).toHaveLength(8);
-    const g2 = scatterAlong(LINE, make, { count: 8, jitter: 4, scaleVar: 0.3, seed: 5 });
-    expect(JSON.stringify(g1)).toBe(JSON.stringify(g2)); // deterministic
-    const g3 = scatterAlong(LINE, make, { count: 8, jitter: 4, scaleVar: 0.3, seed: 6 });
-    expect(JSON.stringify(g1)).not.toBe(JSON.stringify(g3)); // seed changes layout
-  });
-  test('stamps carry a transform (placed along the path)', () => {
-    const g = scatterAlong(LINE, () => circle({ cx: 0, cy: 0, r: 2 }), { count: 3 }) as {
-      children: Array<{ transform?: string }>;
-    };
-    for (const s of g.children) expect(s.transform).toContain('translate(');
-  });
-  test('align rotates stamps to the tangent', () => {
-    const g = scatterAlong(LINE, () => circle({ cx: 0, cy: 0, r: 2 }), {
-      count: 4,
-      align: true,
-    }) as {
-      children: Array<{ transform?: string }>;
-    };
-    expect(g.children.some((s) => (s.transform ?? '').includes('rotate('))).toBe(true);
-  });
-});
-
-describe('L4 hatch / crossHatch (engraving line shading)', () => {
-  const region = { x: 0, y: 0, width: 100, height: 60 };
-  test('hatch fills a region with parallel lines; tighter spacing = more lines (darker)', () => {
-    const sparse = hatch(region, { angle: 45, spacing: 12 }) as {
-      el: string;
-      children: Array<{ el: string }>;
-    };
-    const dense = hatch(region, { angle: 45, spacing: 4 }) as { children: unknown[] };
-    expect(sparse.el).toBe('group');
-    expect(sparse.children.every((c) => c.el === 'line')).toBe(true);
-    expect(dense.children.length).toBeGreaterThan(sparse.children.length);
-  });
-  test('weightVar makes alternating lines differ in width (burin swell)', () => {
-    const g = hatch(region, { spacing: 8, weight: 1, weightVar: 0.5 }) as {
-      children: Array<{ strokeWidth?: number }>;
-    };
-    const widths = new Set(g.children.map((c) => c.strokeWidth));
-    expect(widths.size).toBeGreaterThan(1);
-  });
-  test('crossHatch is two hatch groups at different angles', () => {
-    const g = crossHatch(region, { angle: 30, spacing: 8 }) as { children: Array<{ el: string }> };
-    expect(g.children).toHaveLength(2);
-    expect(g.children.every((c) => c.el === 'group')).toBe(true);
-  });
-});
-
-describe('L5 contourLines + stippleFill (form-following engraving + graded tone)', () => {
-  test('contourLines emits one offset path per offset, following the stroke', () => {
-    const g = contourLines(
-      [
-        { x: 0, y: 0 },
-        { x: 50, y: 10 },
-        { x: 100, y: 0 },
-      ],
-      { offsets: [-8, -4, 0, 4, 8], color: '#caa' }
-    ) as { el: string; children: Array<{ el: string; d: string; stroke?: string; fill?: string }> };
-    expect(g.children).toHaveLength(5);
-    expect(
-      g.children.every((c) => c.el === 'path' && c.fill === 'none' && c.stroke === '#caa')
-    ).toBe(true);
-    expect(g.children[0].d.startsWith('M')).toBe(true);
-    expect(g.children[0].d).toContain('C'); // smooth
-  });
-  test('contourLines count+spacing centers the family on the stroke; deterministic', () => {
-    const a = contourLines(
-      [
-        { x: 0, y: 0 },
-        { x: 100, y: 0 },
-      ],
-      { count: 6, spacing: 5 }
-    ) as { children: unknown[] };
-    expect(a.children).toHaveLength(6);
-    expect(
-      JSON.stringify(
-        contourLines(
-          [
-            { x: 0, y: 0 },
-            { x: 100, y: 0 },
-          ],
-          { count: 6, spacing: 5 }
-        )
-      )
-    ).toBe(JSON.stringify(a));
-  });
-  test('stippleFill density grades the dot count (light vs dark) + deterministic', () => {
-    const region = { x: 0, y: 0, width: 100, height: 100 };
-    const dark = stippleFill(region, { dots: 400, density: () => 1, seed: 3 }) as {
-      children: unknown[];
-    };
-    const light = stippleFill(region, { dots: 400, density: () => 0.1, seed: 3 }) as {
-      children: unknown[];
-    };
-    expect(dark.children.length).toBeGreaterThan(light.children.length * 3);
-    expect(JSON.stringify(stippleFill(region, { dots: 400, density: () => 1, seed: 3 }))).toBe(
-      JSON.stringify(dark)
-    );
-  });
-  test('stippleFill dots land inside the region', () => {
-    const g = stippleFill({ x: 10, y: 20, width: 80, height: 60 }, { dots: 100, seed: 2 }) as {
-      children: Array<{ cx: number; cy: number }>;
-    };
-    for (const d of g.children) {
-      expect(d.cx).toBeGreaterThanOrEqual(10);
-      expect(d.cx).toBeLessThanOrEqual(90);
-      expect(d.cy).toBeGreaterThanOrEqual(20);
-      expect(d.cy).toBeLessThanOrEqual(80);
-    }
-  });
-});
-
-describe('L6 engraveLines (organic per-line burin marks)', () => {
-  const stroke = [
-    { x: 0, y: 0 },
-    { x: 60, y: 8 },
-    { x: 120, y: 0 },
-  ];
-  test('each line is a tapered filled brushStroke (closed path), deterministic', () => {
-    const g = engraveLines(stroke, { count: 8, spacing: 5, seed: 4 }) as {
-      el: string;
-      children: Array<{ el: string; d: string; fill?: string }>;
-    };
-    expect(g.el).toBe('group');
-    expect(g.children.length).toBeGreaterThan(4);
-    expect(g.children.every((c) => c.el === 'path' && c.d.trimEnd().endsWith('Z'))).toBe(true); // filled outline, not stroke
-    expect(JSON.stringify(engraveLines(stroke, { count: 8, spacing: 5, seed: 4 }))).toBe(
-      JSON.stringify(g)
-    );
-  });
-  test('different seeds → different (jittered) output', () => {
-    expect(JSON.stringify(engraveLines(stroke, { count: 8, seed: 1 }))).not.toBe(
-      JSON.stringify(engraveLines(stroke, { count: 8, seed: 2 }))
-    );
-  });
-});

package/apps/studio/draw/test/composition.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  armature,
-  assignSlots,
-  balanceMoment,
-  dominanceRatio,
-  snapToFocal,
-} from '../composition.ts';
-import { apcaLc, bestHarmony, harmonize, harmonyDistance, valueRange } from '../palette.ts';
-
-const BOX = { x: 0, y: 0, width: 90, height: 60 };
-
-describe('armatures', () => {
-  test('thirds power points at exact 1/3 + 2/3', () => {
-    const a = armature(BOX, 'thirds');
-    expect(a.focals).toEqual([
-      { x: 30, y: 20 },
-      { x: 60, y: 20 },
-      { x: 30, y: 40 },
-      { x: 60, y: 40 },
-    ]);
-  });
-  test('rabatment landscape lines at x=H and x=W−H', () => {
-    const a = armature(BOX, 'rabatment'); // W=90,H=60 → x=60, x=30
-    const xs = a.focals.map((f) => f.x).sort((p, q) => p - q);
-    expect(xs[0]).toBe(30);
-    expect(xs[xs.length - 1]).toBe(60);
-  });
-  test('golden points differ from thirds and are inside the box', () => {
-    const a = armature(BOX, 'golden');
-    expect(a.focals).toHaveLength(4);
-    for (const f of a.focals) {
-      expect(f.x).toBeGreaterThan(0);
-      expect(f.x).toBeLessThan(90);
-    }
-    // golden vertical ≈ 90/1.618 = 55.6, not the thirds 60
-    expect(a.focals.some((f) => Math.abs(f.x - 55.6) < 0.5)).toBe(true);
-  });
-  test('dynamic-symmetry yields 4 eyes inside the box, symmetric about center', () => {
-    const a = armature(BOX, 'dynamic-symmetry');
-    expect(a.focals).toHaveLength(4);
-    const cx = a.focals.reduce((s, f) => s + f.x, 0) / 4;
-    const cy = a.focals.reduce((s, f) => s + f.y, 0) / 4;
-    expect(cx).toBeCloseTo(45, 4); // centroid of the 4 eyes = canvas center
-    expect(cy).toBeCloseTo(30, 4);
-  });
-  test('snapToFocal picks the nearest power point', () => {
-    const a = armature(BOX, 'thirds');
-    expect(snapToFocal({ x: 28, y: 22 }, a)).toEqual({ x: 30, y: 20 });
-  });
-});
-
-describe('constraint placement (no random scatter)', () => {
-  test('assignSlots fills focals first, then a calm grid — deterministic', () => {
-    const a = armature(BOX, 'thirds');
-    const p1 = assignSlots(6, a);
-    const p2 = assignSlots(6, a);
-    expect(p1).toEqual(p2); // deterministic
-    expect(p1.slice(0, 4)).toEqual(a.focals); // first 4 land on the power points
-    expect(p1).toHaveLength(6);
-    for (const p of p1) {
-      expect(p.x).toBeGreaterThanOrEqual(0);
-      expect(p.x).toBeLessThanOrEqual(90);
-    }
-  });
-});
-
-describe('VME visual balance', () => {
-  test('a symmetric pair scores ~1 (balanced)', () => {
-    const els = [
-      { bbox: { x: 10, y: 25, width: 10, height: 10 } },
-      { bbox: { x: 70, y: 25, width: 10, height: 10 } },
-    ];
-    const r = balanceMoment(els, BOX);
-    expect(r.score).toBeGreaterThan(0.95);
-  });
-  test('all weight on the left scores low (off-balance)', () => {
-    const els = [
-      { bbox: { x: 2, y: 25, width: 12, height: 12 } },
-      { bbox: { x: 6, y: 5, width: 12, height: 12 } },
-    ];
-    const r = balanceMoment(els, BOX);
-    expect(r.score).toBeLessThan(0.6);
-    expect(r.moment.x).toBeLessThan(0); // mass biased left of center
-  });
-});
-
-describe('dominance', () => {
-  test('one big element dominates; equal elements do not', () => {
-    expect(
-      dominanceRatio([
-        { bbox: { x: 0, y: 0, width: 40, height: 40 } },
-        { bbox: { x: 0, y: 0, width: 10, height: 10 } },
-      ])
-    ).toBeCloseTo(16, 5); // 1600 / 100
-    expect(
-      dominanceRatio([
-        { bbox: { x: 0, y: 0, width: 20, height: 20 } },
-        { bbox: { x: 0, y: 0, width: 20, height: 20 } },
-      ])
-    ).toBeCloseTo(1, 5); // competing foci
-  });
-});
-
-describe('color harmony (Cohen-Or templates)', () => {
-  test('analogous hues score ~0 (harmonious); a clash scores high', () => {
-    const harmonious = bestHarmony([20, 35, 50]); // tight cluster → fits a V/i wedge
-    expect(harmonious.distance).toBeLessThan(5);
-    const clash = bestHarmony([0, 70, 150, 250]); // scattered → no single template covers
-    expect(clash.distance).toBeGreaterThan(harmonious.distance);
-  });
-  test('complementary pair fits the I template near 0', () => {
-    const fit = bestHarmony([30, 210]); // 180° apart → complementary
-    expect(fit.distance).toBeLessThan(5);
-  });
-  test('harmonize snaps an outlier hue into a wedge', () => {
-    // template I = two 18° wedges 180° apart; rotation 30 → wedges at ~30 and ~210
-    const snapped = harmonize([30, 200], 'I', 30);
-    expect(snapped[0]).toBeCloseTo(30, 1); // already inside
-    // 200 is outside the [201,219] wedge → clamps to the near edge (201)
-    expect(Math.abs(snapped[1] - 210)).toBeLessThanOrEqual(9 + 1e-6);
-  });
-  test('harmonyDistance is 0 when all hues sit inside a wedge', () => {
-    expect(harmonyDistance([0, 5, -5], 'i', 0)).toBeCloseTo(0, 6); // i = 18° wedge at 0
-  });
-});
-
-describe('value / contrast metrics', () => {
-  test('valueRange flags a washed-out (muddy) set vs a deep one', () => {
-    const muddy = valueRange(['#b8a0c0', '#a0b8b0', '#c0b0a0']); // all mid-value pastels
-    const deep = valueRange(['#0a0a14', '#ffe7b0']); // near-black ↔ near-white
-    expect(muddy).toBeLessThan(0.2);
-    expect(deep).toBeGreaterThan(0.6);
-  });
-  test('apcaLc: black-on-white is high, same-on-same is ~0', () => {
-    expect(apcaLc('#000000', '#ffffff')).toBeGreaterThan(100);
-    expect(apcaLc('#777777', '#777777')).toBeLessThan(1);
-    // mid-gray text on white clears the body-min Lc 75 only when dark enough
-    expect(apcaLc('#595959', '#ffffff')).toBeGreaterThan(60);
-  });
-});