@micha.bigler/ui-core-micha 3.14.3 → 4.0.0

package/tests/packageTreeShaking.test.js

@@ -1,126 +0,0 @@
-import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { gzipSync } from 'node:zlib';
-
-import { build } from 'vite';
-import { afterAll, expect, test } from 'vitest';
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const packageManifest = JSON.parse(
-  await readFile(path.join(packageRoot, 'package.json'), 'utf8'),
-);
-const packageName = packageManifest.name;
-let temporaryRoot;
-
-async function bundlePackageExport({ caseName, exportName, manifestField }) {
-  temporaryRoot ||= await mkdtemp(path.join(tmpdir(), 'ui-core-tree-shaking-'));
-  const consumerRoot = path.join(temporaryRoot, caseName);
-  const installedPackageRoot = path.join(
-    consumerRoot,
-    'node_modules',
-    ...packageName.split('/'),
-  );
-
-  await mkdir(installedPackageRoot, { recursive: true });
-  await cp(
-    path.join(packageRoot, 'dist'),
-    path.join(installedPackageRoot, 'dist'),
-    { recursive: true },
-  );
-  const installedFontRoot = path.join(
-    consumerRoot,
-    'node_modules',
-    '@fontsource',
-    'dm-sans',
-  );
-  await mkdir(path.dirname(installedFontRoot), { recursive: true });
-  await cp(
-    path.join(packageRoot, 'node_modules', '@fontsource', 'dm-sans'),
-    installedFontRoot,
-    { recursive: true },
-  );
-  await writeFile(
-    path.join(installedPackageRoot, 'package.json'),
-    JSON.stringify({
-      name: packageName,
-      version: packageManifest.version,
-      [manifestField]: packageManifest[manifestField],
-      sideEffects: packageManifest.sideEffects,
-    }),
-  );
-
-  const entryPath = path.join(consumerRoot, 'entry.js');
-  await writeFile(entryPath, `export { ${exportName} } from '${packageName}';\n`);
-
-  const result = await build({
-    configFile: false,
-    logLevel: 'silent',
-    root: consumerRoot,
-    build: {
-      minify: true,
-      rollupOptions: {
-        input: entryPath,
-        preserveEntrySignatures: 'strict',
-        external: (id) => (
-          id !== packageName
-          && !id.startsWith('@fontsource/dm-sans')
-          && !id.startsWith('.')
-          && !path.isAbsolute(id)
-        ),
-        output: {
-          format: 'es',
-        },
-      },
-      write: false,
-    },
-  });
-  const outputs = Array.isArray(result)
-    ? result.flatMap((buildResult) => buildResult.output)
-    : result.output;
-  const entryChunk = outputs.find((output) => output.type === 'chunk' && output.isEntry);
-
-  expect(entryChunk, `${manifestField} entry should produce a bundle`).toBeDefined();
-  return {
-    code: entryChunk.code,
-    css: outputs
-      .filter((output) => output.type === 'asset' && output.fileName.endsWith('.css'))
-      .map((output) => output.source.toString())
-      .join('\n'),
-    rawBytes: Buffer.byteLength(entryChunk.code),
-    gzipBytes: gzipSync(entryChunk.code).byteLength,
-  };
-}
-
-afterAll(async () => {
-  if (temporaryRoot) await rm(temporaryRoot, { recursive: true, force: true });
-});
-
-test('built package entries resolve and unused translation bundles tree-shake', async () => {
-  const authOnly = await bundlePackageExport({
-    caseName: 'auth-main',
-    exportName: 'authTranslations',
-    manifestField: 'main',
-  });
-  const aggregate = await bundlePackageExport({
-    caseName: 'aggregate-module',
-    exportName: 'uiCoreTranslations',
-    manifestField: 'module',
-  });
-
-  expect(authOnly.code).toContain('Auth.LOGIN');
-  expect(authOnly.code).not.toContain('ChartFrame.LOADING');
-  expect(authOnly.css).toContain('DM Sans');
-  expect(aggregate.code).toContain('ChartFrame.LOADING');
-  expect(aggregate.rawBytes).toBeGreaterThan(authOnly.rawBytes);
-  expect(aggregate.gzipBytes).toBeGreaterThan(authOnly.gzipBytes);
-
-  const rawDelta = aggregate.rawBytes - authOnly.rawBytes;
-  const gzipDelta = aggregate.gzipBytes - authOnly.gzipBytes;
-  console.info(
-    `tree-shaking measurement: auth=${authOnly.rawBytes} B raw/${authOnly.gzipBytes} B gzip; `
-      + `aggregate=${aggregate.rawBytes} B raw/${aggregate.gzipBytes} B gzip; `
-      + `delta=+${rawDelta} B raw/+${gzipDelta} B gzip`,
-  );
-}, 15_000);

package/tests/realtime.test.jsx

@@ -1,219 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-
-const feedApi = vi.hoisted(() => ({
-  getNotificationFeed: vi.fn(),
-  getUnreadCount: vi.fn(),
-  markNotifications: vi.fn(),
-}));
-
-vi.mock('../src/notifications/feedApi', () => feedApi);
-
-import { AuthContext } from '../src/auth/AuthContext';
-import { NotificationsProvider, useNotifications } from '../src/notifications/NotificationsProvider';
-import { useRealtime } from '../src/notifications/realtime';
-
-class MockWebSocket {
-  static instances = [];
-
-  constructor(url) {
-    this.url = url;
-    this.close = vi.fn(() => this.onclose?.());
-    MockWebSocket.instances.push(this);
-  }
-}
-
-function StreamConsumer({ envelope, testId }) {
-  const { subscribe } = useRealtime();
-  const [received, setReceived] = React.useState([]);
-
-  React.useEffect(
-    () => subscribe(envelope, (data) => setReceived((prev) => [...prev, data])),
-    [subscribe, envelope],
-  );
-
-  return <output data-testid={testId}>{JSON.stringify(received)}</output>;
-}
-
-function ReconnectConsumer() {
-  const { onReconnect } = useRealtime();
-  const [count, setCount] = React.useState(0);
-  React.useEffect(() => onReconnect(() => setCount((current) => current + 1)), [onReconnect]);
-  return <output data-testid="reconnect-count">{count}</output>;
-}
-
-function NotificationsConsumer() {
-  const notifications = useNotifications();
-  return (
-    <>
-      <output data-testid="notifications">{JSON.stringify(notifications.notifications)}</output>
-      <output data-testid="unread-count">{notifications.unreadCount}</output>
-      <output data-testid="context-keys">{JSON.stringify(Object.keys(notifications).sort())}</output>
-    </>
-  );
-}
-
-function renderWithStreams({ streams = [], user = { id: 4 } } = {}) {
-  return render(
-    <AuthContext.Provider value={{ user }}>
-      <NotificationsProvider>
-        <NotificationsConsumer />
-        {streams.map(({ envelope, testId }) => (
-          <StreamConsumer key={testId} envelope={envelope} testId={testId} />
-        ))}
-      </NotificationsProvider>
-    </AuthContext.Provider>,
-  );
-}
-
-function received(testId) {
-  return JSON.parse(screen.getByTestId(testId).textContent);
-}
-
-describe('realtime primitive (NOTIF-13)', () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    MockWebSocket.instances = [];
-    vi.stubGlobal('WebSocket', MockWebSocket);
-    feedApi.getNotificationFeed.mockResolvedValue({ results: [] });
-    feedApi.getUnreadCount.mockResolvedValue({ count: 0 });
-    feedApi.markNotifications.mockResolvedValue({ updated: 1 });
-  });
-
-  it('ignores an unknown/unsubscribed envelope type — feed and unreadCount untouched', async () => {
-    renderWithStreams();
-    await waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-
-    MockWebSocket.instances[0].onmessage({ data: JSON.stringify({
-      envelope: 'message',
-      type: 'chat.new',
-      body: 'hello',
-    }) });
-
-    expect(screen.getByTestId('unread-count').textContent).toBe('0');
-    expect(currentNotificationsAreEmpty()).toBe(true);
-  });
-
-  function currentNotificationsAreEmpty() {
-    return JSON.parse(screen.getByTestId('notifications').textContent).length === 0;
-  }
-
-  it('routes two subscribers on distinct envelope types from one socket, each seeing only their own', async () => {
-    renderWithStreams({ streams: [
-      { envelope: 'message', testId: 'message-stream' },
-      { envelope: 'other', testId: 'other-stream' },
-    ] });
-    await waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-
-    MockWebSocket.instances[0].onmessage({ data: JSON.stringify({ envelope: 'message', body: 'a' }) });
-    MockWebSocket.instances[0].onmessage({ data: JSON.stringify({ envelope: 'other', body: 'b' }) });
-
-    await waitFor(() => expect(received('message-stream')).toHaveLength(1));
-    expect(received('message-stream')[0]).toEqual(expect.objectContaining({ body: 'a' }));
-    expect(received('other-stream')).toHaveLength(1);
-    expect(received('other-stream')[0]).toEqual(expect.objectContaining({ body: 'b' }));
-    expect(MockWebSocket.instances).toHaveLength(1);
-  });
-
-  it('unsubscribe stops delivery for that subscriber without affecting others', async () => {
-    function Harness() {
-      const { subscribe } = useRealtime();
-      const [messageReceived, setMessageReceived] = React.useState([]);
-      const [otherReceived, setOtherReceived] = React.useState([]);
-      const [messageSubscribed, setMessageSubscribed] = React.useState(true);
-
-      React.useEffect(() => {
-        if (!messageSubscribed) return undefined;
-        return subscribe('message', (data) => setMessageReceived((prev) => [...prev, data]));
-      }, [subscribe, messageSubscribed]);
-
-      React.useEffect(
-        () => subscribe('other', (data) => setOtherReceived((prev) => [...prev, data])),
-        [subscribe],
-      );
-
-      return (
-        <>
-          <output data-testid="message-received">{JSON.stringify(messageReceived)}</output>
-          <output data-testid="other-received">{JSON.stringify(otherReceived)}</output>
-          <button onClick={() => setMessageSubscribed(false)}>unsubscribe-message</button>
-        </>
-      );
-    }
-
-    const { unmount } = render(
-      <AuthContext.Provider value={{ user: { id: 4 } }}>
-        <NotificationsProvider>
-          <Harness />
-        </NotificationsProvider>
-      </AuthContext.Provider>,
-    );
-    await waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-
-    fireEvent.click(screen.getByRole('button', { name: 'unsubscribe-message' }));
-
-    MockWebSocket.instances[0].onmessage({ data: JSON.stringify({ envelope: 'message', body: 'after-unsub' }) });
-    MockWebSocket.instances[0].onmessage({ data: JSON.stringify({ envelope: 'other', body: 'still-alive' }) });
-
-    await waitFor(() => expect(received('other-received')).toHaveLength(1));
-    expect(received('message-received')).toHaveLength(0);
-    expect(received('other-received')[0]).toEqual(expect.objectContaining({ body: 'still-alive' }));
-
-    unmount();
-  });
-
-  it('keeps a subscriber registered across a close/backoff/reopen cycle with no re-registration', async () => {
-    vi.useFakeTimers();
-    try {
-      renderWithStreams({ streams: [{ envelope: 'message', testId: 'message-stream' }] });
-      await vi.waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-
-      const firstSocket = MockWebSocket.instances[0];
-      firstSocket.onclose();
-      await vi.advanceTimersByTimeAsync(1_000);
-
-      expect(MockWebSocket.instances).toHaveLength(2);
-      MockWebSocket.instances[1].onmessage({ data: JSON.stringify({ envelope: 'message', body: 'after-reopen' }) });
-
-      await vi.waitFor(() => expect(received('message-stream')).toHaveLength(1));
-      expect(received('message-stream')[0]).toEqual(expect.objectContaining({ body: 'after-reopen' }));
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('additively signals consumers when a closed connection re-establishes', async () => {
-    vi.useFakeTimers();
-    try {
-      render(
-        <AuthContext.Provider value={{ user: { id: 4 } }}>
-          <NotificationsProvider><ReconnectConsumer /></NotificationsProvider>
-        </AuthContext.Provider>,
-      );
-      await vi.waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-      MockWebSocket.instances[0].onopen();
-      expect(screen.getByTestId('reconnect-count').textContent).toBe('0');
-      MockWebSocket.instances[0].onclose();
-      await vi.advanceTimersByTimeAsync(1_000);
-      MockWebSocket.instances[1].onopen();
-      await vi.waitFor(() => expect(screen.getByTestId('reconnect-count').textContent).toBe('1'));
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("NotificationsProvider's public context value is unchanged", async () => {
-    renderWithStreams();
-    await waitFor(() => expect(MockWebSocket.instances).toHaveLength(1));
-
-    expect(JSON.parse(screen.getByTestId('context-keys').textContent)).toEqual(
-      ['markDismissed', 'markDone', 'markSeen', 'notifications', 'refresh', 'unreadCount'].sort(),
-    );
-  });
-});

package/tests/resolveErrorText.test.js

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveErrorText } from '../src/utils/resolveErrorText';
-
-function makeI18n(values) {
-  return {
-    exists: (key) => Object.hasOwn(values, key),
-    t: (key) => values[key] ?? `missing:${key}`,
-  };
-}
-
-describe('resolveErrorText', () => {
-  it('prefers an explicit backend i18nKey over every lower-priority source', () => {
-    const i18n = makeI18n({
-      'Auth.explicit': 'Explicit text',
-      'Auth.field.email.invalid': 'Field text',
-      invalid: 'Code text',
-      'Auth.DEFAULT': 'Default text',
-    });
-
-    expect(resolveErrorText(i18n, {
-      i18nKey: 'Auth.explicit',
-      field: 'email',
-      code: 'invalid',
-      backendMessage: 'Backend text',
-    }, 'Auth.DEFAULT')).toBe('Explicit text');
-  });
-
-  it('uses the allauth param as a field-specific key before the code', () => {
-    const i18n = makeI18n({
-      'Auth.field.email.invalid': 'Field text',
-      invalid: 'Code text',
-      'Auth.DEFAULT': 'Default text',
-    });
-
-    expect(resolveErrorText(i18n, {
-      field: 'email',
-      code: 'invalid',
-      backendMessage: 'Backend text',
-    }, 'Auth.DEFAULT')).toBe('Field text');
-  });
-
-  it('uses the code catalogue entry when no field entry exists', () => {
-    const i18n = makeI18n({
-      email_password_mismatch: 'Code text',
-      'Auth.DEFAULT': 'Default text',
-    });
-
-    expect(resolveErrorText(i18n, {
-      field: 'email',
-      code: 'email_password_mismatch',
-      backendMessage: 'Backend text',
-    }, 'Auth.DEFAULT')).toBe('Code text');
-  });
-
-  it('uses the backend message before the caller default', () => {
-    const i18n = makeI18n({ 'Auth.DEFAULT': 'Default text' });
-
-    expect(resolveErrorText(i18n, {
-      code: 'unknown_backend_code',
-      backendMessage: 'Backend text',
-    }, 'Auth.DEFAULT')).toBe('Backend text');
-  });
-
-  it('uses the caller default instead of ever returning an unknown raw code', () => {
-    const i18n = makeI18n({ 'Auth.DEFAULT': 'Default text' });
-
-    expect(resolveErrorText(i18n, {
-      code: 'unknown_backend_code',
-    }, 'Auth.DEFAULT')).toBe('Default text');
-    expect(resolveErrorText(i18n, null, 'Auth.DEFAULT')).toBe('Default text');
-  });
-});

package/tests/stepSelection.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { selectActiveSteps } from '../src/onboarding/stepSelection';
-
-const context = {
-  user: { first_name: 'Ada', last_name: 'Lovelace', accepted_convenience_cookies: true },
-  pushState: { supported: true, subscribed: false },
-};
-
-const step = (id, condition, options = {}) => ({
-  id,
-  condition,
-  persistDismissed: options.persistDismissed ?? false,
-});
-
-describe('selectActiveSteps', () => {
-  it('excludes a config-disabled universal step', () => {
-    const result = selectActiveSteps([step('cookie_consent', () => true)], { cookie_consent: false }, context);
-    expect(result).toEqual([]);
-  });
-
-  it('excludes a persistently dismissed browser push step', () => {
-    const result = selectActiveSteps(
-      [step('browser_push', () => true, { persistDismissed: true })],
-      { browser_push: true },
-      context,
-      new Set(['browser_push']),
-    );
-    expect(result).toEqual([]);
-  });
-
-  it('filters steps whose condition is not met', () => {
-    const result = selectActiveSteps(
-      [step('complete_name', (ctx) => !ctx.user.first_name)],
-      { complete_name: true },
-      context,
-    );
-    expect(result).toEqual([]);
-  });
-
-  it('preserves descriptor order for active universal steps', () => {
-    const steps = [
-      step('cookie_consent', () => true),
-      step('complete_name', () => true),
-      step('browser_push', () => true, { persistDismissed: true }),
-    ];
-    const result = selectActiveSteps(steps, {
-      cookie_consent: true,
-      complete_name: true,
-      browser_push: true,
-    }, context);
-    expect(result.map((item) => item.id)).toEqual(['cookie_consent', 'complete_name', 'browser_push']);
-  });
-});