jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/tests/unit/codexChatAttachmentState.spec.ts

@@ -0,0 +1,71 @@
+import { expect, test } from '@playwright/test';
+
+import { resolveCellAttachmentState } from '../../src/codexChatAttachmentState';
+
+test('resolveCellAttachmentState shows notebook cell attachment for jupytext notebook editor', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'jupytext_py',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: true,
+    contentEnabled: true,
+    outputEnabled: true
+  });
+});
+
+test('resolveCellAttachmentState hides cell attachment for jupytext text editor', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'jupytext_py',
+      isNotebookEditor: false,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: false,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});
+
+test('resolveCellAttachmentState hides badge for plain python notebook mode', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'plain_py',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: false,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});
+
+test('resolveCellAttachmentState keeps the toggle visible when attachment is off', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: false,
+      includeActiveCellOutput: true,
+      notebookMode: 'ipynb',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.ipynb',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: true,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});

package/tests/unit/codexChatDocumentUtils.spec.ts

@@ -0,0 +1,63 @@
+import { expect, test } from '@playwright/test';
+
+import {
+  ACTIVE_CELL_OUTPUT_MAX_CHARS,
+  summarizeJupyterOutputs,
+  toMessageSelectionPreview
+} from '../../src/codexChatDocumentUtils';
+
+test('toMessageSelectionPreview keeps line labels for jupytext text-editor selections', () => {
+  expect(
+    toMessageSelectionPreview(
+      { kind: 'line', number: 7, text: 'print("hello")\nprint("world")' },
+      null,
+      'jupytext_py',
+      'print("hello")\nprint("world")'
+    )
+  ).toEqual({
+    locationLabel: 'Line 7',
+    previewText: 'print("hello")\nprint("world")'
+  });
+});
+
+test('toMessageSelectionPreview uses the attached text after payload truncation', () => {
+  expect(
+    toMessageSelectionPreview(
+      { kind: 'cell', number: 3, text: 'original content that was longer' },
+      null,
+      'ipynb',
+      'trimmed content'
+    )
+  ).toEqual({
+    locationLabel: 'Cell 3',
+    previewText: 'trimmed content'
+  });
+});
+
+test('summarizeJupyterOutputs keeps the start of non-error output when truncating', () => {
+  const output = summarizeJupyterOutputs([
+    {
+      output_type: 'stream',
+      name: 'stdout',
+      text: 'A'.repeat(ACTIVE_CELL_OUTPUT_MAX_CHARS + 100)
+    }
+  ]);
+
+  expect(output.startsWith('A'.repeat(16))).toBeTruthy();
+  expect(output.endsWith('... (truncated)')).toBeTruthy();
+  expect(output.length).toBeLessThanOrEqual(ACTIVE_CELL_OUTPUT_MAX_CHARS);
+});
+
+test('summarizeJupyterOutputs keeps the end of error output when truncating', () => {
+  const tail = 'ValueError: final failure details';
+  const output = summarizeJupyterOutputs([
+    {
+      output_type: 'error',
+      traceback: ['trace line', 'B'.repeat(ACTIVE_CELL_OUTPUT_MAX_CHARS), tail]
+    }
+  ]);
+
+  expect(output.startsWith('... (truncated)')).toBeTruthy();
+  expect(output.endsWith(tail)).toBeTruthy();
+  expect(output.length).toBeLessThanOrEqual(ACTIVE_CELL_OUTPUT_MAX_CHARS);
+});

package/tests/unit/codexChatLimit.spec.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { expect, test } from '@playwright/test';
+
+test('codex chat session history cap is set to 100 entries', () => {
+  const source = readFileSync(resolve(__dirname, '../../src/codexChat.tsx'), 'utf8');
+  const match = source.match(/const MAX_SESSION_MESSAGES = (\d+);/);
+
+  expect(match).not.toBeNull();
+  expect(Number(match?.[1])).toBe(100);
+});
+
+test('codex chat trims session history using the configured max entry count', () => {
+  const source = readFileSync(resolve(__dirname, '../../src/codexChat.tsx'), 'utf8');
+
+  expect(source).toContain('if (messages.length <= MAX_SESSION_MESSAGES) {');
+  expect(source).toContain('return messages.slice(messages.length - MAX_SESSION_MESSAGES);');
+});

package/tests/unit/codexChatNotice.spec.ts

@@ -0,0 +1,45 @@
+import { expect, test } from '@playwright/test';
+
+import { isSessionStartNotice, normalizeSessionStartedNotice } from '../../src/codexChatNotice';
+
+test('normalizeSessionStartedNotice keeps English start notice format', () => {
+  const normalized = normalizeSessionStartedNotice('Session started (10:00 AM)');
+  expect(normalized).toBe('Session started (10:00 AM)');
+});
+
+test('normalizeSessionStartedNotice keeps Korean start notice', () => {
+  const normalized = normalizeSessionStartedNotice('세션이 시작되었습니다');
+  expect(normalized).toBe('세션이 시작되었습니다');
+});
+
+test('normalizeSessionStartedNotice accepts Korean start notice with timestamp', () => {
+  const normalized = normalizeSessionStartedNotice('새 스레드 시작됨 (14:00)');
+  expect(normalized).toBe('새 스레드 시작됨 (14:00)');
+});
+
+test('normalizeSessionStartedNotice accepts Japanese/Chinese locale forms', () => {
+  expect(normalizeSessionStartedNotice('会話を開始しました (21:45)')).toBe('会話を開始しました (21:45)');
+  expect(normalizeSessionStartedNotice('对话开始')).toBe('对话开始');
+});
+
+test('isSessionStartNotice accepts locale variants', () => {
+  expect(isSessionStartNotice('Session start: resumed')).toBe(true);
+  expect(isSessionStartNotice('세션 시작 됨')).toBe(true);
+  expect(isSessionStartNotice('세션이 시작되었습니다')).toBe(true);
+  expect(isSessionStartNotice('new thread started')).toBe(true);
+  expect(isSessionStartNotice('会話を開始しました')).toBe(true);
+  expect(isSessionStartNotice('会话开始')).toBe(true);
+  expect(isSessionStartNotice('スレッドが開始')).toBe(true);
+  expect(isSessionStartNotice('セッション開始')).toBe(true);
+  expect(isSessionStartNotice('Nueva sesión iniciada')).toBe(true);
+  expect(isSessionStartNotice('任意 메세지', 'new')).toBe(true);
+  expect(isSessionStartNotice('irrelevant text', 'mapping')).toBe(true);
+});
+
+test('isSessionStartNotice rejects unrelated system messages', () => {
+  expect(isSessionStartNotice('No start token found')).toBe(false);
+  expect(isSessionStartNotice('Authentication required')).toBe(false);
+  expect(isSessionStartNotice('Session is running normally')).toBe(false);
+  expect(isSessionStartNotice('会話は進行中です')).toBe(false);
+  expect(isSessionStartNotice('Session already running', null)).toBe(false);
+});

package/tests/unit/codexChatPersistence.spec.ts

@@ -0,0 +1,199 @@
+import { expect, test } from '@playwright/test';
+
+import {
+  coerceSessionThreadSyncEvent,
+  buildSessionThreadSyncEvent,
+  getStoredSessionThreadCount,
+  hasDeleteAllPending,
+  hasStoredDeleteAllPending,
+  markDeleteAllPending,
+  parseSessionKey,
+  persistStoredSessionThreads,
+  readStoredSessionThreads,
+  readStoredThreadId,
+  STORAGE_KEY_SESSION_THREADS,
+  STORAGE_KEY_SESSION_THREADS_EVENT,
+  writeSessionThreadSyncEvent,
+  clearDeleteAllPending,
+  STORAGE_KEY_DELETE_ALL_PENDING
+} from '../../src/codexChatPersistence';
+
+type FakeStorage = {
+  clear: () => void;
+  getItem: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  setItem: (key: string, value: string) => void;
+};
+
+function createInMemoryStorage(): FakeStorage {
+  const data = new Map<string, string>();
+  return {
+    clear: () => {
+      data.clear();
+    },
+    getItem: key => data.get(key) ?? null,
+    removeItem: key => {
+      data.delete(key);
+    },
+    setItem: (key, value) => {
+      data.set(key, value);
+    }
+  };
+}
+
+const fakeStorage = createInMemoryStorage();
+(globalThis as any).window = {
+  localStorage: fakeStorage
+} as any;
+
+test.beforeEach(() => {
+  fakeStorage.clear();
+});
+
+function separatorText(): string {
+  return '\u0000';
+}
+
+test('parseSessionKey returns raw session path when no separator exists', () => {
+  const parsed = parseSessionKey('/tmp/notebook.ipynb');
+  expect(parsed.path).toBe('/tmp/notebook.ipynb');
+});
+
+test('parseSessionKey extracts path before first separator when present', () => {
+  const path = '/tmp/notebook.ipynb';
+  const key = `${path}${separatorText()}run`;
+  expect(parseSessionKey(key).path).toBe(path);
+});
+
+test('getStoredSessionThreadCount dedupes by normalized path', () => {
+  fakeStorage.clear();
+  const path = '/tmp/notebook.ipynb';
+  fakeStorage.setItem(
+    STORAGE_KEY_SESSION_THREADS,
+    JSON.stringify({
+      [`${path}${separatorText()}abc`]: 'thread-abc',
+      [`${path}${separatorText()}def`]: 'thread-def',
+      [`other${separatorText()}x`]: 'thread-x'
+    })
+  );
+
+  expect(getStoredSessionThreadCount()).toBe(2);
+});
+
+test('readStoredThreadId uses exact session key first then fallback by path', () => {
+  fakeStorage.clear();
+  fakeStorage.setItem(
+    STORAGE_KEY_SESSION_THREADS,
+    JSON.stringify({
+      [`/tmp/foo${separatorText()}one`]: 'thread-one',
+      [`/tmp/foo${separatorText()}two`]: 'thread-two'
+    })
+  );
+
+  expect(readStoredThreadId('/tmp/foo', `/tmp/foo${separatorText()}two`)).toBe('thread-two');
+  expect(readStoredThreadId('/tmp/foo', '/tmp/foo:missing')).toBe('thread-one');
+  expect(readStoredThreadId('/tmp/bar', `/tmp/bar${separatorText()}x`)).toBe('');
+});
+
+test('persistStoredSessionThreads stores only valid session keys with thread ids', () => {
+  fakeStorage.clear();
+  const sessions = new Map([
+    ['doc-a', { threadId: 'thread-a' }],
+    ['', { threadId: 'ignored' }],
+    ['doc-b', {} as { threadId?: string }],
+    ['doc-c', { threadId: 'thread-c' }]
+  ]);
+  persistStoredSessionThreads(sessions);
+
+  const raw = fakeStorage.getItem(STORAGE_KEY_SESSION_THREADS);
+  expect(raw).toBeTruthy();
+  const parsed = raw ? JSON.parse(raw) : {};
+  expect(parsed).toEqual({
+    'doc-a': 'thread-a',
+    'doc-c': 'thread-c'
+  });
+});
+
+test('readStoredSessionThreads parses valid json object', () => {
+  fakeStorage.clear();
+  fakeStorage.setItem(STORAGE_KEY_SESSION_THREADS, JSON.stringify({ docA: 'thread-a', docB: 1 }));
+  expect(readStoredSessionThreads()).toEqual({ docA: 'thread-a' });
+});
+
+test('coerceSessionThreadSyncEvent parses and validates payload', () => {
+  const payload = JSON.stringify({
+    kind: 'new-thread',
+    sessionKey: '  docA ',
+    notebookPath: ' /tmp/file.ipynb ',
+    threadId: '  t1 ',
+    source: 'local-tab',
+    id: 'evt-1',
+    issuedAt: 1719852800000
+  });
+  const event = coerceSessionThreadSyncEvent(payload);
+  expect(event).toEqual({
+    kind: 'new-thread',
+    sessionKey: 'docA',
+    notebookPath: '/tmp/file.ipynb',
+    threadId: 't1',
+    source: 'local-tab',
+    id: 'evt-1',
+    issuedAt: 1719852800000
+  });
+});
+
+test('coerceSessionThreadSyncEvent returns null for malformed payload', () => {
+  expect(coerceSessionThreadSyncEvent('not-json')).toBeNull();
+  expect(coerceSessionThreadSyncEvent(JSON.stringify({ kind: 'wrong', sessionKey: 'a', notebookPath: 'b', threadId: 'c', id: 'd' }))).toBeNull();
+});
+
+test('buildSessionThreadSyncEvent normalizes values and sets issue time', () => {
+  const issuedAt = Date.now();
+  const event = buildSessionThreadSyncEvent({
+    sessionKey: ' /tmp/doc ',
+    notebookPath: '/tmp/doc ',
+    threadId: ' thread-1 ',
+    source: ' local ',
+    createEventId: () => 'evt-1'
+  });
+  expect(event).toMatchObject({
+    kind: 'new-thread',
+    sessionKey: '/tmp/doc',
+    notebookPath: '/tmp/doc',
+    threadId: 'thread-1',
+    source: 'local',
+    id: 'evt-1'
+  });
+  expect(event.issuedAt).toBeGreaterThanOrEqual(issuedAt);
+});
+
+test('writeSessionThreadSyncEvent persists serialized event', () => {
+  fakeStorage.clear();
+  const event = buildSessionThreadSyncEvent({
+    sessionKey: 'doc',
+    notebookPath: '/tmp/doc',
+    threadId: 't1',
+    source: 'local',
+    createEventId: () => 'evt-1'
+  });
+  writeSessionThreadSyncEvent(event);
+
+  const saved = fakeStorage.getItem(STORAGE_KEY_SESSION_THREADS_EVENT);
+  expect(saved).toBeTruthy();
+  expect(saved).toEqual(JSON.stringify(event));
+});
+
+test('delete-all pending helpers track persistence state', () => {
+  fakeStorage.clear();
+  expect(hasDeleteAllPending()).toBe(false);
+  expect(hasStoredDeleteAllPending()).toBe(false);
+
+  markDeleteAllPending();
+  expect(hasDeleteAllPending()).toBe(true);
+  expect(hasStoredDeleteAllPending()).toBe(true);
+  expect(fakeStorage.getItem(STORAGE_KEY_DELETE_ALL_PENDING)).toBe('1');
+
+  clearDeleteAllPending();
+  expect(hasDeleteAllPending()).toBe(false);
+  expect(hasStoredDeleteAllPending()).toBe(false);
+});

package/tests/unit/codexChatSessionFactory.spec.ts

@@ -0,0 +1,94 @@
+import { expect, test } from '@playwright/test';
+
+import { createSession, createThreadResetSession } from '../../src/codexChatSessionFactory';
+
+const defaultDeps = {
+  readStoredThreadId(path: string, sessionKey: string): string {
+    return sessionKey === 'stored' && path === '/tmp/notebook' ? 'stored-thread' : '';
+  },
+  readDefaultModelOption(): string {
+    return '__config__';
+  },
+  readDefaultReasoningEffortOption(): string {
+    return 'medium';
+  },
+  readDefaultSandboxModeOption(): string {
+    return 'workspace-write';
+  },
+  normalizeSystemText(role: 'user' | 'assistant' | 'system', text: string): string {
+    return role === 'system' && text.startsWith('Session started') ? `normalized:${text}` : text;
+  }
+};
+
+test('createSession falls back to stored thread id when thread id missing', () => {
+  const session = createSession<{ threadId: string; messages: Array<{ role: string; text: string }>; [key: string]: unknown }>(
+    '/tmp/notebook',
+    'Session started',
+    { sessionKey: 'stored' },
+    defaultDeps
+  );
+  expect(session.threadId).toBe('stored-thread');
+});
+
+test('createSession uses explicit thread id when provided', () => {
+  const session = createSession<{ threadId: string; messages: Array<{ role: string; text: string }>; [key: string]: unknown }>(
+    '/tmp/notebook',
+    'Session started',
+    { threadId: 'explicit-thread' },
+    defaultDeps
+  );
+  expect(session.threadId).toBe('explicit-thread');
+});
+
+test('createSession seeds selected defaults and system text normalized', () => {
+  const session = createSession<{
+    threadId: string;
+    messages: Array<{ kind: 'text'; role: 'system'; text: string }>;
+    selectedModelOption: string;
+    selectedReasoningEffort: string;
+    selectedSandboxMode: string;
+    effectiveSandboxMode: unknown;
+    conversationMode: 'resume' | 'fallback';
+    notebookMode: null;
+    runState: 'ready' | 'running';
+    activeRunId: string | null;
+    runStartedAt: number | null;
+    progress: string;
+    progressKind: '' | 'reasoning';
+    pairedOk: boolean | null;
+    pairedPath: string;
+    pairedOsPath: string;
+    pairedMessage: string;
+  }>(
+    '/tmp/notebook',
+    'Session started',
+    { sessionKey: '' },
+    defaultDeps
+  );
+  expect(session.selectedModelOption).toBe('__config__');
+  expect(session.selectedReasoningEffort).toBe('medium');
+  expect(session.selectedSandboxMode).toBe('workspace-write');
+  expect(session.conversationMode).toBe('resume');
+  expect(session.messages[0].text).toBe('normalized:Session started');
+  expect(session.progress).toBe('');
+  expect(session.runState).toBe('ready');
+});
+
+test('createThreadResetSession uses time label and forced thread id', () => {
+  const originalToLocaleTimeString = Date.prototype.toLocaleTimeString;
+  Date.prototype.toLocaleTimeString = () => '14:00:00';
+  const session = createThreadResetSession<{
+    threadId: string;
+    messages: Array<{ kind: 'text'; role: string; text: string }>;
+    [key: string]: unknown;
+  }>(
+    '/tmp/notebook',
+    'doc-key',
+    'thread-reset',
+    defaultDeps
+  );
+  expect(session.threadId).toBe('thread-reset');
+  expect(session.messages[0].text).toBe('normalized:Session started (14:00:00)');
+  Date.prototype.toLocaleTimeString = originalToLocaleTimeString;
+});
+

package/tests/unit/codexChatSessionKey.spec.ts

@@ -0,0 +1,18 @@
+import { expect, test } from '@playwright/test';
+
+import { makeSessionKey, resolveCurrentSessionKey, resolveSessionKey } from '../../src/codexChatSessionKey';
+
+test('makeSessionKey trims and keeps empty fallback', () => {
+  expect(makeSessionKey('  /tmp/notebook.ipynb  ')).toBe('/tmp/notebook.ipynb');
+  expect(makeSessionKey('   ')).toBe('');
+});
+
+test('resolveSessionKey normalizes via makeSessionKey', () => {
+  expect(resolveSessionKey('/tmp/notebook.ipynb')).toBe('/tmp/notebook.ipynb');
+  expect(resolveSessionKey('   ')).toBe('');
+});
+
+test('resolveCurrentSessionKey delegates to resolveSessionKey', () => {
+  expect(resolveCurrentSessionKey('/tmp/other.ipynb')).toBe('/tmp/other.ipynb');
+});
+

package/tests/unit/codexMessageUtils.spec.ts

@@ -0,0 +1,89 @@
+import { test, expect } from '@playwright/test';
+
+import {
+  coerceMessageContextPreview,
+  coerceRateLimitsSnapshot,
+  coerceSelectionPreview,
+  coerceSessionHistory,
+  splitStoredMessagePreview,
+  truncateEnd
+} from '../../src/handlers/codexMessageUtils';
+
+test('coerceSelectionPreview enforces required fields', () => {
+  expect(coerceSelectionPreview({ locationLabel: 'Cell 1', previewText: 'hello' })).toEqual({
+    locationLabel: 'Cell 1',
+    previewText: 'hello'
+  });
+  expect(coerceSelectionPreview({ locationLabel: '', previewText: 'hello' })).toBeUndefined();
+  expect(truncateEnd('abcdef', 3)).toBe('abc');
+  expect(truncateEnd('abcdef', 6)).toBe('abcdef');
+});
+
+test('coerceMessageContextPreview supports legacy and nested shapes', () => {
+  expect(
+    coerceMessageContextPreview({
+      selectionPreview: { locationLabel: 'Selection', previewText: 'abc' },
+      cellOutputPreview: { locationLabel: 'Output', previewText: 'xyz' }
+    })
+  ).toEqual({
+    selectionPreview: { locationLabel: 'Selection', previewText: 'abc' },
+    cellOutputPreview: { locationLabel: 'Output', previewText: 'xyz' }
+  });
+
+  expect(coerceMessageContextPreview({ locationLabel: 'Legacy', previewText: 'text' })).toEqual({
+    selectionPreview: { locationLabel: 'Legacy', previewText: 'text' }
+  });
+});
+
+test('coerceSessionHistory drops invalid entries', () => {
+  expect(
+    coerceSessionHistory([
+      { role: 'user', content: 'hello', selectionPreview: { locationLabel: 'Cell', previewText: 'x' } },
+      { role: 'invalid', content: 'bad' },
+      { role: 'assistant', content: 'ok', extra: 'x' }
+    ])
+  ).toEqual([
+    { role: 'user', content: 'hello', selectionPreview: { locationLabel: 'Cell', previewText: 'x' }, cellOutputPreview: undefined },
+    { role: 'assistant', content: 'ok', selectionPreview: undefined, cellOutputPreview: undefined }
+  ]);
+});
+
+test('coerceRateLimitsSnapshot normalizes nested windows and context window', () => {
+  const snapshot = coerceRateLimitsSnapshot({
+    updatedAt: '2024-01-01T00:00:00Z',
+    primary: { usedPercent: '20.1', windowMinutes: '10.2', resetsAt: '99.9' },
+    secondary: { usedPercent: '12.2', windowMinutes: '5', resetsAt: '40' },
+    contextWindow: { windowTokens: '10.5', usedTokens: '5.2', leftTokens: '4.8', usedPercent: '50.5' }
+  });
+  expect(snapshot).toEqual({
+    updatedAt: '2024-01-01T00:00:00Z',
+    primary: { usedPercent: 20.1, windowMinutes: 10, resetsAt: 100 },
+    secondary: { usedPercent: 12.2, windowMinutes: 5, resetsAt: 40 },
+    contextWindow: { windowTokens: 11, usedTokens: 5, leftTokens: 5, usedPercent: 50.5 }
+  });
+});
+
+test('coerceRateLimitsSnapshot treats blank numeric strings as null', () => {
+  const snapshot = coerceRateLimitsSnapshot({
+    updatedAt: '2024-01-01T00:00:00Z',
+    primary: { usedPercent: '', windowMinutes: '   ', resetsAt: 'NaN' },
+    contextWindow: { windowTokens: '', usedTokens: '   ', leftTokens: 'none', usedPercent: '50' }
+  });
+  expect(snapshot).toEqual({
+    updatedAt: '2024-01-01T00:00:00Z',
+    primary: { usedPercent: null, windowMinutes: null, resetsAt: null },
+    secondary: null,
+    contextWindow: { windowTokens: null, usedTokens: null, leftTokens: null, usedPercent: 50 }
+  });
+});
+
+test('splitStoredMessagePreview handles nested and legacy payloads', () => {
+  expect(splitStoredMessagePreview({ selectionPreview: { a: 1 }, cellOutputPreview: { b: 2 } })).toEqual({
+    selectionPreview: { a: 1 },
+    cellOutputPreview: { b: 2 }
+  });
+
+  expect(splitStoredMessagePreview({ locationLabel: 'x', previewText: 'y' })).toEqual({
+    selectionPreview: { locationLabel: 'x', previewText: 'y' }
+  });
+});