@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/asciiTimelineRender.test.ts

@@ -1,376 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  asciiTimelineToTemplateData,
-  detectAsciiTimeline,
-  parseAsciiTimeline,
-  renderAsciiTimeline,
-  type AsciiTimeline,
-} from '../doc/asciiTimeline/index.js';
-import {
-  TICK_INTERPOLATION_TIMELINE,
-  WRAPPED_CLIENT_KERNEL_TIMELINE,
-} from './fixtures/asciiTimelines.js';
-
-function renderFixpoint(timeline: AsciiTimeline, style?: 'unicode' | 'ascii'): string {
-  const first = renderAsciiTimeline(timeline, style ? { style } : {});
-  const second = renderAsciiTimeline(parseAsciiTimeline(first));
-  const third = renderAsciiTimeline(parseAsciiTimeline(second));
-  expect(second).toBe(first);
-  expect(third).toBe(first);
-  return first;
-}
-
-describe('renderAsciiTimeline', () => {
-  const timeline: AsciiTimeline = {
-    tracks: [
-      {
-        id: 'kernel',
-        label: 'kernel ticks (30 Hz)',
-        row: 4,
-        startColumn: 20,
-        endColumn: 65,
-        events: [
-          {
-            id: 'tick-28',
-            label: 'T28',
-            description: 'delta-28',
-            column: 22,
-            side: 'above',
-            marker: 'filled',
-          },
-          {
-            id: 'tick-29',
-            label: 'T29',
-            column: 38,
-            side: 'below',
-            marker: 'hollow',
-          },
-        ],
-      },
-      {
-        id: 'branch',
-        label: 'client frames',
-        row: 9,
-        startColumn: 30,
-        endColumn: 55,
-        events: [
-          {
-            id: 'render-point',
-            label: 'render position',
-            description: 'interpolate T28 to T29',
-            column: 42,
-            marker: 'diamond',
-          },
-        ],
-      },
-    ],
-    links: [{ source: 'tick-28', target: 'render-point', label: 'feeds renderer' }],
-    width: 80,
-    height: 12,
-    style: 'unicode',
-    warnings: [],
-  };
-
-  it('emits a continuous rail with pointer callouts and branch declarations', () => {
-    const output = renderFixpoint(timeline);
-    const lines = output.split('\n');
-    const kernelRail = lines.find((line) => line.includes('kernel ticks (30 Hz)'));
-
-    expect(kernelRail).toMatch(/kernel ticks \(30 Hz\) \{#kernel start=20 end=65\}: ─*●─*○─*►/u);
-    expect(output).toContain('▲ T28 :: delta-28 {#tick-28 column=22}');
-    expect(output).toContain('▼ T29 {#tick-29 column=38}');
-    expect(lines[lines.length - 1]).toBe('branch: tick-28 → render-point : feeds renderer');
-  });
-
-  it('uses parser-recognizable ASCII markers and rails', () => {
-    const output = renderFixpoint(timeline, 'ascii');
-
-    expect(output).toMatch(/^kernel ticks \(30 Hz\) \{#kernel start=20 end=65\}: -*\*-*o-*>/m);
-    expect(output).toContain('^ T28 :: delta-28 {#tick-28 column=22}');
-    expect(output).toContain('v T29 {#tick-29 column=38}');
-    expect(output).toContain('branch: tick-28 -> render-point : feeds renderer');
-    expect(output).not.toMatch(/[─●○◆►→]/u);
-  });
-
-  it('sorts tracks/events and drops unresolved links before the first render', () => {
-    const shuffled: AsciiTimeline = {
-      ...timeline,
-      tracks: [...timeline.tracks].reverse().map((track) => ({
-        ...track,
-        events: [...track.events].reverse(),
-      })),
-      links: [...timeline.links, { source: 'missing', target: 'tick-28' }],
-    };
-    const output = renderFixpoint(shuffled);
-
-    expect(output.indexOf('kernel ticks')).toBeLessThan(output.indexOf('client frames'));
-    expect(output.indexOf('T28')).toBeLessThan(output.indexOf('T29'));
-    expect(output).not.toContain('missing');
-  });
-
-  it('normalizes colliding ids and prose-heavy Unicode without fixpoint churn', () => {
-    const adversarial: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'one',
-          row: 0,
-          startColumn: 0,
-          endColumn: 20,
-          events: [
-            { id: 'same', label: 'oooooooooooo', column: 0 },
-            { id: 'same', label: 'second', column: 10 },
-            { id: 'same_2', label: 'third', column: 20 },
-          ],
-        },
-      ],
-      links: [],
-      width: 21,
-      height: 1,
-      style: 'unicode',
-      warnings: [],
-    };
-    const output = renderFixpoint(adversarial);
-
-    expect(output).toContain('{#same column=0}');
-    expect(output).toContain('{#same_2 column=10}');
-    expect(output).toContain('{#same_2_2 column=20}');
-    expect(parseAsciiTimeline(output).style).toBe('unicode');
-  });
-
-  it('preserves shared geometry when track labels have different lengths', () => {
-    const geometry: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'short',
-          label: 'A',
-          row: 0,
-          startColumn: 10,
-          endColumn: 110,
-          events: [
-            { id: 'a20', label: '20', column: 20 },
-            { id: 'a90', label: '90', column: 90 },
-          ],
-        },
-        {
-          id: 'long',
-          label: 'A much longer parallel track label',
-          row: 3,
-          startColumn: 10,
-          endColumn: 110,
-          events: [
-            { id: 'b20', label: '20', column: 20 },
-            { id: 'b90', label: '90', column: 90 },
-          ],
-        },
-      ],
-      links: [],
-      width: 111,
-      height: 4,
-      style: 'unicode',
-      warnings: [],
-    };
-    const before = asciiTimelineToTemplateData(geometry).tracks.map((track) =>
-      track.events.map((event) => event.position),
-    );
-    const rendered = renderFixpoint(geometry);
-    const parsed = parseAsciiTimeline(rendered);
-    const after = asciiTimelineToTemplateData(parsed).tracks.map((track) =>
-      track.events.map((event) => event.position),
-    );
-
-    expect(parsed.tracks.map((track) => [track.startColumn, track.endColumn])).toEqual([
-      [10, 110],
-      [10, 110],
-    ]);
-    expect(after).toEqual(before);
-  });
-
-  it('preserves internal arrows and double hyphens in event prose', () => {
-    const prose: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'flow',
-          label: 'Flow',
-          row: 0,
-          startColumn: 0,
-          endColumn: 20,
-          events: [
-            {
-              id: 'compare',
-              label: 'Compare',
-              description: 'A > B; release--candidate',
-              column: 10,
-            },
-          ],
-        },
-      ],
-      links: [],
-      width: 21,
-      height: 1,
-      style: 'unicode',
-      warnings: [],
-    };
-    const parsed = parseAsciiTimeline(renderFixpoint(prose));
-
-    expect(parsed.tracks[0].events[0].description).toBe('A > B; release--candidate');
-  });
-
-  it('canonicalizes the exact sample without losing its cadence or callout semantics', () => {
-    const parsed = parseAsciiTimeline(TICK_INTERPOLATION_TIMELINE);
-    const before = asciiTimelineToTemplateData(parsed).tracks.map((track) =>
-      track.events.map((event) => event.position),
-    );
-    const output = renderFixpoint(parsed);
-    expect(detectAsciiTimeline(output).isTimeline).toBe(true);
-    expect(detectAsciiTimeline(output, { explicit: true }).isTimeline).toBe(true);
-    const reparsed = parseAsciiTimeline(output);
-    const [kernel, client] = reparsed.tracks;
-
-    expect(reparsed.tracks).toHaveLength(2);
-    expect(kernel.endLabel).toBe('sim time');
-    expect(kernel.events[0]).toMatchObject({
-      label: 'T28',
-      description: 'deltas sent: Δ28',
-      side: 'above',
-      descriptionSide: 'below',
-    });
-    expect(client.events.filter((event) => event.callout === false)).toHaveLength(16);
-    expect(client.events.map((event) => event.label)).toEqual(
-      expect.arrayContaining(['estimated kernel clock', 'render position']),
-    );
-    expect(
-      asciiTimelineToTemplateData(reparsed).tracks.map((track) =>
-        track.events.map((event) => event.position),
-      ),
-    ).toEqual(before);
-  });
-
-  it('canonicalizes wrapped flow art into a byte-stable point timeline', () => {
-    const wrapped = parseAsciiTimeline(WRAPPED_CLIENT_KERNEL_TIMELINE);
-    const output = renderFixpoint(wrapped);
-    const reparsed = parseAsciiTimeline(output);
-
-    expect(output).toContain('CLIENT (main thread)');
-    expect(output).toContain('KERNEL (Web Worker / Node)');
-    expect(output).toContain('branch: command-rejected-event → error-surfaced-to-user-agent');
-    expect(reparsed.tracks.map((track) => track.events.map((event) => event.id))).toEqual(
-      wrapped.tracks.map((track) => track.events.map((event) => event.id)),
-    );
-    expect(reparsed.links).toEqual(wrapped.links);
-  });
-
-  it('round-trips a hyphenated label ending in an ASCII-marker letter', () => {
-    const hyphenated: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'flow',
-          row: 0,
-          startColumn: 0,
-          endColumn: 20,
-          events: [
-            { id: 'go', label: 'Go-live', column: 0 },
-            { id: 'done', label: 'Done', column: 20 },
-          ],
-        },
-      ],
-      links: [],
-      width: 21,
-      height: 1,
-      style: 'unicode',
-      warnings: [],
-    };
-
-    const parsed = parseAsciiTimeline(renderFixpoint(hyphenated));
-    expect(parsed.tracks[0].events.map((event) => [event.id, event.label])).toEqual([
-      ['go', 'Go-live'],
-      ['done', 'Done'],
-    ]);
-  });
-
-  it('does not treat marker letters beside double hyphens as ASCII events', () => {
-    const doubleHyphen: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'ascii-flow',
-          row: 0,
-          startColumn: 0,
-          endColumn: 10,
-          events: [{ id: 'foo', label: 'foo--bar', column: 5 }],
-        },
-      ],
-      links: [],
-      width: 11,
-      height: 1,
-      style: 'ascii',
-      warnings: [],
-    };
-
-    const parsed = parseAsciiTimeline(renderFixpoint(doubleHyphen, 'ascii'));
-    expect(parsed.tracks[0].events).toMatchObject([{ id: 'foo', label: 'foo--bar' }]);
-  });
-
-  it('round-trips brace-delimited prose in a track end label', () => {
-    const braceSuffix: AsciiTimeline = {
-      tracks: [
-        {
-          id: 'release',
-          row: 0,
-          startColumn: 0,
-          endColumn: 10,
-          endLabel: 'status {beta}',
-          events: [
-            { id: 'a', label: 'A', column: 0 },
-            { id: 'b', label: 'B', column: 10 },
-          ],
-        },
-      ],
-      links: [],
-      width: 11,
-      height: 1,
-      style: 'unicode',
-      warnings: [],
-    };
-
-    const parsed = parseAsciiTimeline(renderFixpoint(braceSuffix));
-    expect(parsed.tracks[0].endLabel).toBe('status {beta}');
-    expect(parsed.tracks[0].events.map((event) => [event.id, event.label])).toEqual([
-      ['a', 'A'],
-      ['b', 'B'],
-    ]);
-  });
-
-  it.each(['unicode', 'ascii'] as const)(
-    'normalizes leading rail prose without %s fixpoint churn',
-    (style) => {
-      const leadingRails: AsciiTimeline = {
-        tracks: [
-          {
-            id: 'flags',
-            endLabel: '─-done',
-            row: 0,
-            startColumn: 0,
-            endColumn: 20,
-            events: [
-              { id: 'watch', label: '--watch', column: 0 },
-              { id: 'negative', label: '-1.5', column: 10 },
-              { id: 'phase', label: '─phase', column: 20 },
-            ],
-          },
-        ],
-        links: [],
-        width: 21,
-        height: 1,
-        style,
-        warnings: [],
-      };
-      const parsed = parseAsciiTimeline(renderFixpoint(leadingRails, style));
-
-      expect(parsed.tracks[0].events.map((event) => event.label)).toEqual([
-        '−−watch',
-        '−1.5',
-        '–phase',
-      ]);
-      expect(parsed.tracks[0].endLabel).toBe('–−done');
-    },
-  );
-});

package/src/__tests__/atmosphereLayers.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { expandPersistentLayer } from '../doc/templates/persistentLayers.js';
-import { cssFilterForTreatment } from '../doc/utils/imageTreatment.js';
-import { themedImageTreatment } from '../doc/utils/themeUtils.js';
-import { createTemplateContext } from '../schemas/BlockTemplates.js';
-import { DEFAULT_THEME, resolveTheme } from '../schemas/themeLibrary.js';
-import { validateTheme } from '../schemas/themeValidator.js';
-import { THEMES } from '../schemas/themeLibrary.js';
-import type { ShapeLayer, ImageLayer } from '../schemas/Doc.js';
-
-describe('atmosphere persistent layers', () => {
-  it('patternBackground expands dots/grid/diagonal to an SVG pattern fill', () => {
-    const [layer] = expandPersistentLayer({
-      template: 'patternBackground',
-      config: { type: 'patternBackground', pattern: 'grid', color: '#00e5ff', opacity: 0.04 },
-    }) as ShapeLayer[];
-    expect(layer.type).toBe('shape');
-    expect(layer.content.pattern).toEqual({
-      kind: 'grid',
-      color: '#00e5ff',
-      size: 24,
-      opacity: 0.04,
-    });
-  });
-
-  it('patternBackground noise expands to a grain filter rect', () => {
-    const [layer] = expandPersistentLayer({
-      template: 'patternBackground',
-      config: { type: 'patternBackground', pattern: 'noise', opacity: 0.05 },
-    }) as ShapeLayer[];
-    expect(layer.content.filter).toEqual({ type: 'noise', opacity: 0.05 });
-  });
-
-  it('vignette expands to a radial gradient rect with strength-scaled edge', () => {
-    const [layer] = expandPersistentLayer({
-      template: 'vignette',
-      config: { type: 'vignette', strength: 0.4 },
-    }) as ShapeLayer[];
-    expect(layer.content.fill).toContain('radial-gradient');
-    expect(layer.content.fill).toContain('rgba(0, 0, 0, 0.4)');
-  });
-
-  it('ambientGradient derives colors from the theme and drifts slowly', () => {
-    const theme = resolveTheme('gezellig');
-    const [layer] = expandPersistentLayer(
-      { template: 'ambientGradient', config: { type: 'ambientGradient' } },
-      theme,
-    ) as ShapeLayer[];
-    expect(layer.content.fill).toContain(theme.colors.backgroundLight);
-    expect(layer.animation?.type).toBe('slowZoom');
-    expect(layer.animation?.duration).toBe(40);
-    // Oversized so the pan never reveals the frame edge
-    expect(layer.position.width).toBe('110%');
-  });
-
-  it('imageBackground passes blur through to the image layer', () => {
-    const [image] = expandPersistentLayer({
-      template: 'imageBackground',
-      config: { type: 'imageBackground', src: 'bg.jpg', blur: 12 },
-    }) as ImageLayer[];
-    expect(image.content.blur).toBe(12);
-  });
-
-  it('every built-in theme still validates with its atmosphere layers', () => {
-    for (const [id, theme] of Object.entries(THEMES)) {
-      const result = validateTheme(theme);
-      expect(result.valid, `theme ${id}: ${JSON.stringify(result.errors)}`).toBe(true);
-    }
-  });
-});
-
-describe('image treatments', () => {
-  it('mono produces a grayscale filter scaled by strength', () => {
-    expect(cssFilterForTreatment({ type: 'mono', strength: 1 })).toContain('grayscale(1)');
-    expect(cssFilterForTreatment({ type: 'mono', strength: 0.5 })).toContain('grayscale(0.5)');
-  });
-
-  it('duotone rotates hue toward the tint color', () => {
-    // #ff0000 has hue 0 → rotation 0 - 40 = -40deg
-    const f = cssFilterForTreatment({ type: 'duotone', color: '#ff0000' });
-    expect(f).toContain('grayscale(1)');
-    expect(f).toContain('hue-rotate(-40deg)');
-  });
-
-  it('none / absent treatments produce no filter', () => {
-    expect(cssFilterForTreatment({ type: 'none' })).toBeUndefined();
-    expect(cssFilterForTreatment(undefined)).toBeUndefined();
-  });
-
-  it('blur composes with (or without) a treatment', () => {
-    expect(cssFilterForTreatment(undefined, 12)).toBe('blur(12px)');
-    expect(cssFilterForTreatment({ type: 'mono' }, 8)).toMatch(/^blur\(8px\) grayscale/);
-  });
-
-  it('themedImageTreatment: block override wins, none opts out, duotone tints from primary', () => {
-    const documentary = resolveTheme('documentary');
-    const ctx = createTemplateContext(documentary, 0, 1);
-    // Theme authors mono
-    expect(themedImageTreatment(ctx)?.type).toBe('mono');
-    // Block opts out
-    expect(themedImageTreatment(ctx, 'none')).toBeUndefined();
-    // Block forces duotone → tint defaults to theme primary
-    expect(themedImageTreatment(ctx, 'duotone')?.color).toBe(documentary.colors.primary);
-    // Standard theme has no treatment
-    const plainCtx = createTemplateContext(DEFAULT_THEME, 0, 1);
-    expect(themedImageTreatment(plainCtx)).toBeUndefined();
-  });
-});

package/src/__tests__/attrTokens.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  tokenizeAttrTokens,
-  splitKeyValueToken,
-  unquoteAttrValue,
-  needsQuoting,
-  quoteAttrValue,
-  matchTrailingTemplateAnnotation,
-  matchTrailingPandocAttr,
-} from '../markdown/attrTokens.js';
-
-describe('tokenizeAttrTokens', () => {
-  it('splits bare tokens on whitespace', () => {
-    expect(tokenizeAttrTokens('chart colorScheme=blue size=large')).toEqual([
-      'chart',
-      'colorScheme=blue',
-      'size=large',
-    ]);
-  });
-
-  it('keeps a double-quoted value as one token', () => {
-    expect(tokenizeAttrTokens('caption="Beach at sunset" columns=3')).toEqual([
-      'caption="Beach at sunset"',
-      'columns=3',
-    ]);
-  });
-
-  it('keeps a single-quoted value as one token', () => {
-    expect(tokenizeAttrTokens("caption='Beach at sunset'")).toEqual(["caption='Beach at sunset'"]);
-  });
-
-  it('treats a quote mid-value as a literal character', () => {
-    // The quote in O'Brien is not at a value start, so it must not open a
-    // quoted run and swallow the following token.
-    expect(tokenizeAttrTokens("attribution=O'Brien x=4")).toEqual(["attribution=O'Brien", 'x=4']);
-  });
-
-  it('preserves escape pairs inside a quoted run', () => {
-    expect(tokenizeAttrTokens('label="he said \\"hi\\""')).toEqual(['label="he said \\"hi\\""']);
-  });
-
-  it('tolerates an unbalanced opening quote (run extends to end of input)', () => {
-    expect(tokenizeAttrTokens('caption="oops trailing')).toEqual(['caption="oops trailing']);
-  });
-
-  it('keeps a bare quoted token verbatim', () => {
-    expect(tokenizeAttrTokens('"just a string"')).toEqual(['"just a string"']);
-  });
-});
-
-describe('splitKeyValueToken / unquoteAttrValue', () => {
-  it('splits on the first =', () => {
-    expect(splitKeyValueToken('a=b=c')).toEqual({ key: 'a', value: 'b=c' });
-  });
-
-  it('returns null for tokens without = past the first character', () => {
-    expect(splitKeyValueToken('chart')).toBeNull();
-    expect(splitKeyValueToken('#id')).toBeNull();
-    expect(splitKeyValueToken('=leading')).toBeNull();
-  });
-
-  it('strips matching double quotes and unescapes', () => {
-    expect(splitKeyValueToken('label="he said \\"hi\\""')).toEqual({
-      key: 'label',
-      value: 'he said "hi"',
-    });
-  });
-
-  it('strips matching single quotes and unescapes', () => {
-    expect(splitKeyValueToken("label='it\\'s here'")).toEqual({ key: 'label', value: "it's here" });
-  });
-
-  it('leaves unmatched quotes verbatim', () => {
-    expect(unquoteAttrValue('"unbalanced')).toBe('"unbalanced');
-    expect(unquoteAttrValue('"')).toBe('"');
-  });
-
-  it('leaves backslashes before other characters alone', () => {
-    expect(unquoteAttrValue('"C:\\temp"')).toBe('C:\\temp');
-  });
-});
-
-describe('needsQuoting / quoteAttrValue', () => {
-  it('passes simple values through bare', () => {
-    expect(quoteAttrValue('blue')).toBe('blue');
-    expect(quoteAttrValue('a,b,c')).toBe('a,b,c');
-    expect(quoteAttrValue('foo:flow')).toBe('foo:flow');
-  });
-
-  it('double-quotes values with spaces', () => {
-    expect(quoteAttrValue('Beach at sunset')).toBe('"Beach at sunset"');
-  });
-
-  it('quotes empty values', () => {
-    expect(quoteAttrValue('')).toBe('""');
-  });
-
-  it('quotes values containing brackets or braces', () => {
-    expect(needsQuoting('a]b')).toBe(true);
-    expect(quoteAttrValue('a]b')).toBe('"a]b"');
-    expect(quoteAttrValue('a}b')).toBe('"a}b"');
-  });
-
-  it('switches to single quotes when the value contains a double quote', () => {
-    expect(quoteAttrValue('She said "hi"')).toBe('\'She said "hi"\'');
-  });
-
-  it('falls back to double quotes with escapes when both quote chars appear', () => {
-    expect(quoteAttrValue('it\'s a "thing"')).toBe('"it\'s a \\"thing\\""');
-  });
-
-  it('round-trips through tokenize + split', () => {
-    const values = ['Beach at sunset', 'a ] b', 'She said "hi"', "it's fine", 'C:\\temp', ''];
-    for (const value of values) {
-      const tokens = tokenizeAttrTokens(`key=${quoteAttrValue(value)}`);
-      expect(tokens).toHaveLength(1);
-      expect(splitKeyValueToken(tokens[0])).toEqual({ key: 'key', value });
-    }
-  });
-});
-
-describe('matchTrailingTemplateAnnotation', () => {
-  it('matches an empty trailing annotation', () => {
-    const m = matchTrailingTemplateAnnotation('Heading {[]}');
-    expect(m?.inner).toBe('');
-  });
-
-  it('matches a simple trailing annotation', () => {
-    const m = matchTrailingTemplateAnnotation('Getting Started {[comparisonBar]}');
-    expect(m?.inner).toBe('comparisonBar');
-  });
-
-  it('allows ] inside a quoted value', () => {
-    const m = matchTrailingTemplateAnnotation('X {[quote text="a ] b"]}');
-    expect(m?.inner).toBe('quote text="a ] b"');
-  });
-
-  it('falls back to the legacy grammar for unbalanced quotes', () => {
-    const m = matchTrailingTemplateAnnotation('X {[quote text="oops]}');
-    expect(m?.inner).toBe('quote text="oops');
-  });
-
-  it('still tolerates an accidentally doubled trailing ]}', () => {
-    const m = matchTrailingTemplateAnnotation('X {[comparisonBar]}]}');
-    expect(m?.inner).toBe('comparisonBar');
-  });
-
-  it('rejects non-trailing annotations', () => {
-    expect(matchTrailingTemplateAnnotation('The {[chart]} section')).toBeNull();
-  });
-});
-
-describe('matchTrailingPandocAttr', () => {
-  it('matches a simple trailing block', () => {
-    const m = matchTrailingPandocAttr('Section {#intro .wide x=4}');
-    expect(m?.inner).toBe('#intro .wide x=4');
-  });
-
-  it('allows } inside a quoted value', () => {
-    const m = matchTrailingPandocAttr('X {caption="a } b"}');
-    expect(m?.inner).toBe('caption="a } b"');
-  });
-
-  it('does not match the {[…]} template form', () => {
-    expect(matchTrailingPandocAttr('X {[chart]}')).toBeNull();
-  });
-});