instant-cli 1.0.33 → 1.0.34-branch-webhooks-docs.25934100514.1

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> instant-cli@1.0.33 build /home/runner/work/instant/instant/client/packages/cli
+> instant-cli@1.0.34-branch-webhooks-docs.25934100514.1 build /home/runner/work/instant/instant/client/packages/cli
 > rm -rf dist; tsc -p tsconfig.build.json
 

package/__tests__/multiSelect.test.ts

@@ -0,0 +1,236 @@
+import { test, expect, describe } from 'vitest';
+import { UI } from '../src/ui/index.ts';
+
+const key = (
+  name: string,
+  overrides: { ctrl?: boolean; meta?: boolean; shift?: boolean } = {},
+) => ({
+  sequence: name,
+  name,
+  ctrl: overrides.ctrl ?? false,
+  meta: overrides.meta ?? false,
+  shift: overrides.shift ?? false,
+});
+
+const space = key('space');
+const down = key('down');
+const up = key('up');
+const pageDown = key('pagedown');
+const pageUp = key('pageup');
+const ret = key('return');
+const esc = key('escape');
+const back = key('backspace');
+const ch = (c: string) => ({
+  sequence: c,
+  name: c,
+  ctrl: false,
+  meta: false,
+  shift: false,
+});
+
+class FakeTerminal {
+  resolved: { data: unknown; status: string } | null = null;
+  toggleCursor(_state: 'hide' | 'show') {}
+  requestLayout() {}
+  setAllowInteraction(_v: boolean) {}
+  resolve(value: any) {
+    this.resolved = value;
+  }
+}
+
+const setup = <T>(props: any) => {
+  const ms = new UI.MultiSelect<T>(props);
+  const term = new FakeTerminal();
+  ms.attach(term as any);
+  return { ms, term };
+};
+
+const strOpts = (...values: string[]) =>
+  values.map((v) => ({ value: v, label: v }));
+
+describe('MultiSelect navigation', () => {
+  test('space toggles current item', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b'),
+      promptText: 'p',
+    });
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['a']);
+  });
+
+  test('down moves cursor forward', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b'),
+      promptText: 'p',
+    });
+    ms.input(undefined, down);
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['b']);
+  });
+
+  test('down wraps from last to first', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b'),
+      promptText: 'p',
+    });
+    ms.input(undefined, down);
+    ms.input(undefined, down);
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['a']);
+  });
+
+  test('up wraps from first to last', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b', 'c'),
+      promptText: 'p',
+    });
+    ms.input(undefined, up);
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['c']);
+  });
+
+  test('pageDown moves cursor by pageSize', () => {
+    const opts = Array.from({ length: 15 }, (_, i) => ({
+      value: `o${i}`,
+      label: `o${i}`,
+    }));
+    const { ms } = setup<string>({
+      options: opts,
+      promptText: 'p',
+      pageSize: 5,
+    });
+    ms.input(undefined, pageDown); // 0 → 5
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['o5']);
+  });
+
+  test('pageUp clamps at 0', () => {
+    const opts = Array.from({ length: 5 }, (_, i) => ({
+      value: `o${i}`,
+      label: `o${i}`,
+    }));
+    const { ms } = setup<string>({
+      options: opts,
+      promptText: 'p',
+      pageSize: 10,
+    });
+    ms.input(undefined, pageUp);
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['o0']);
+  });
+});
+
+describe('MultiSelect selection', () => {
+  test('initialSelected reflects in result', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b', 'c'),
+      promptText: 'p',
+      initialSelected: ['a', 'c'],
+    });
+    expect(ms.result()).toEqual(['a', 'c']);
+  });
+
+  test('space twice deselects', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a'),
+      promptText: 'p',
+    });
+    ms.input(' ', space);
+    ms.input(' ', space);
+    expect(ms.result()).toEqual([]);
+  });
+
+  test('result returns in original option order, not selection order', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b', 'c'),
+      promptText: 'p',
+    });
+    ms.input(undefined, down);
+    ms.input(undefined, down); // cursor at c
+    ms.input(' ', space); // select c
+    ms.input(undefined, up);
+    ms.input(undefined, up); // cursor at a
+    ms.input(' ', space); // select a
+    ms.input(undefined, down);
+    ms.input(' ', space); // select b
+    expect(ms.result()).toEqual(['a', 'b', 'c']);
+  });
+});
+
+describe('MultiSelect filtering', () => {
+  test('typing narrows visible options; space toggles a visible match', () => {
+    const { ms } = setup<string>({
+      options: strOpts('posts', 'comments', 'authors'),
+      promptText: 'p',
+    });
+    'posts'.split('').forEach((c) => ms.input(c, ch(c)));
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['posts']);
+  });
+
+  test('filter with no matches: space is a no-op', () => {
+    const { ms } = setup<string>({
+      options: strOpts('a', 'b'),
+      promptText: 'p',
+    });
+    ms.input('z', ch('z'));
+    ms.input(' ', space);
+    expect(ms.result()).toEqual([]);
+  });
+
+  test('backspace shortens filter and restores options', () => {
+    const { ms } = setup<string>({
+      options: strOpts('posts', 'comments'),
+      promptText: 'p',
+    });
+    ms.input('z', ch('z'));
+    ms.input(undefined, back); // filter empty again
+    ms.input(' ', space); // toggles posts (first visible)
+    expect(ms.result()).toEqual(['posts']);
+  });
+
+  test('case-insensitive filter by default', () => {
+    const { ms } = setup<string>({
+      options: strOpts('Posts', 'Comments'),
+      promptText: 'p',
+    });
+    ms.input('p', ch('p'));
+    ms.input(' ', space);
+    expect(ms.result()).toEqual(['Posts']);
+  });
+});
+
+describe('MultiSelect submit / cancel', () => {
+  test('return submits result when minSelected is satisfied', () => {
+    const { ms, term } = setup<string>({
+      options: strOpts('a'),
+      promptText: 'p',
+      minSelected: 1,
+    });
+    ms.input(' ', space);
+    ms.input(undefined, ret);
+    expect(term.resolved).toEqual({ data: ['a'], status: 'submitted' });
+  });
+
+  test('return does not submit when below minSelected', () => {
+    const { ms, term } = setup<string>({
+      options: strOpts('a'),
+      promptText: 'p',
+      minSelected: 1,
+    });
+    ms.input(undefined, ret);
+    expect(term.resolved).toBeNull();
+  });
+
+  test('escape aborts', () => {
+    const { ms, term } = setup<string>({
+      options: strOpts('a'),
+      promptText: 'p',
+    });
+    ms.input(undefined, esc);
+    expect(term.resolved).toEqual({
+      data: undefined,
+      status: 'aborted',
+    });
+  });
+});

package/__tests__/select.test.ts

@@ -0,0 +1,224 @@
+import { test, expect, describe } from 'vitest';
+import stripAnsi from 'strip-ansi';
+import { UI } from '../src/ui/index.ts';
+
+const key = (name: string) => ({
+  sequence: name,
+  name,
+  ctrl: false,
+  meta: false,
+  shift: false,
+});
+
+const tab = key('tab');
+const down = key('down');
+const up = key('up');
+
+class FakeTerminal {
+  toggleCursor(_state: 'hide' | 'show') {}
+  requestLayout() {}
+  setAllowInteraction(_v: boolean) {}
+  resolve(_v: any) {}
+}
+
+const setup = <T>(props: any) => {
+  const sel = new UI.Select<T>(props);
+  const term = new FakeTerminal();
+  sel.attach(term as any);
+  return { sel, term };
+};
+
+const tick = () => new Promise<void>((r) => setImmediate(r));
+
+describe('Select expansion', () => {
+  test('Tab is a no-op when option has no expandableLabel', () => {
+    const { sel } = setup({
+      options: [{ value: 'a', label: 'a' }],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).not.toContain('expanded');
+  });
+
+  test('Tab shows a static expandableLabel string', () => {
+    const { sel } = setup({
+      options: [
+        {
+          value: 'a',
+          label: 'a',
+          expandableLabel: '    static-detail-line',
+        },
+      ],
+      promptText: 'p',
+    });
+    expect(stripAnsi(sel.render('idle'))).not.toContain('static-detail-line');
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).toContain('static-detail-line');
+  });
+
+  test('Tab twice collapses', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a', expandableLabel: '    static-detail' },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).not.toContain('static-detail');
+  });
+
+  test('Sticky mode: navigating to another expandable auto-expands it', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a-row', expandableLabel: '    a-detail' },
+        { value: 'b', label: 'b-row', expandableLabel: '    b-detail' },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).toContain('a-detail');
+    sel.input(undefined, down);
+    const out = stripAnsi(sel.render('idle'));
+    expect(out).not.toContain('a-detail');
+    expect(out).toContain('b-detail');
+  });
+
+  test('Sticky mode: navigating to non-expandable hides expansion but stays sticky', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a', expandableLabel: '    a-detail' },
+        { value: 'b', label: 'b' },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    sel.input(undefined, down); // move to b, no expansion
+    let out = stripAnsi(sel.render('idle'));
+    expect(out).not.toContain('a-detail');
+    expect(out).toContain('(tab to collapse)');
+    sel.input(undefined, up); // back to a — should auto-expand again
+    out = stripAnsi(sel.render('idle'));
+    expect(out).toContain('a-detail');
+  });
+
+  test('Without Tab, navigation does not auto-expand', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a', expandableLabel: '    a-detail' },
+        { value: 'b', label: 'b', expandableLabel: '    b-detail' },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, down);
+    const out = stripAnsi(sel.render('idle'));
+    expect(out).not.toContain('a-detail');
+    expect(out).not.toContain('b-detail');
+  });
+
+  test('Async expandableLabel shows Loading then resolves', async () => {
+    let resolveFn!: (s: string) => void;
+    const promise = new Promise<string>((r) => {
+      resolveFn = r;
+    });
+    const { sel } = setup({
+      options: [
+        {
+          value: 'a',
+          label: 'a',
+          expandableLabel: () => promise,
+        },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).toContain('Loading');
+    resolveFn('    resolved-content-here');
+    await tick();
+    await tick();
+    expect(stripAnsi(sel.render('idle'))).toContain('resolved-content-here');
+  });
+
+  test('Async expandableLabel caches result across collapse/re-expand', async () => {
+    let calls = 0;
+    const { sel } = setup({
+      options: [
+        {
+          value: 'a',
+          label: 'a',
+          expandableLabel: () => {
+            calls++;
+            return Promise.resolve('    cached');
+          },
+        },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    await tick();
+    expect(calls).toBe(1);
+    sel.input(undefined, tab); // collapse
+    sel.input(undefined, tab); // re-expand
+    expect(calls).toBe(1);
+    expect(stripAnsi(sel.render('idle'))).toContain('cached');
+  });
+
+  test('Async expandableLabel rejection shows error in expansion', async () => {
+    const { sel } = setup({
+      options: [
+        {
+          value: 'a',
+          label: 'a',
+          expandableLabel: () => Promise.reject(new Error('boom')),
+        },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, tab);
+    await tick();
+    await tick();
+    expect(stripAnsi(sel.render('idle'))).toMatch(/Error loading.*boom/);
+  });
+
+  test('Hint shown whenever any option has expandableLabel', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a', expandableLabel: '    detail' },
+        { value: 'b', label: 'b' },
+      ],
+      promptText: 'p',
+    });
+    expect(stripAnsi(sel.render('idle'))).toContain('(tab to expand)');
+    sel.input(undefined, tab);
+    expect(stripAnsi(sel.render('idle'))).toContain('(tab to collapse)');
+    // Moving to a non-expandable row keeps the hint (sticky mode is active)
+    sel.input(undefined, down);
+    expect(stripAnsi(sel.render('idle'))).toContain('(tab to collapse)');
+  });
+
+  test('Hint not shown when no option has expandableLabel', () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a' },
+        { value: 'b', label: 'b' },
+      ],
+      promptText: 'p',
+    });
+    expect(stripAnsi(sel.render('idle'))).not.toMatch(/tab to/);
+  });
+
+  test('Tab only expands the focused row', async () => {
+    const { sel } = setup({
+      options: [
+        { value: 'a', label: 'a-row', expandableLabel: '    detail-a' },
+        { value: 'b', label: 'b-row', expandableLabel: '    detail-b' },
+      ],
+      promptText: 'p',
+    });
+    sel.input(undefined, down); // focus b
+    sel.input(undefined, tab);
+    const out = stripAnsi(sel.render('idle'));
+    expect(out).toContain('detail-b');
+    expect(out).not.toContain('detail-a');
+  });
+});