@rangka/client 0.1.0 → 0.1.2

package/src/widgets/__tests__/split-widget.test.tsx

@@ -1,133 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import React from 'react';
-import { render, cleanup } from '@testing-library/react';
-import { registerWidget, clearWidgetRegistry } from '../registry.js';
-import { SplitWidget } from '../components/SplitWidget.js';
-import { WidgetContextProvider } from '../hooks/useWidgetContext.js';
-import { PageStateProvider } from '../hooks/usePageState.js';
-import { StateStore } from '../state/store.js';
-import type { WidgetProps } from '../types.js';
-import type { ComponentType } from 'react';
-import type { WidgetNode } from '@rangka/shared';
-
-vi.mock('react-resizable-panels', () => ({
-  Group: ({ children, className }: { children: React.ReactNode; className?: string }) => (
-    <div data-testid="panel-group" className={className}>
-      {children}
-    </div>
-  ),
-  Panel: ({ children, defaultSize }: { children: React.ReactNode; defaultSize?: number }) => (
-    <div data-testid="panel" data-default-size={defaultSize}>
-      {children}
-    </div>
-  ),
-  Separator: ({ children }: { children?: React.ReactNode }) => (
-    <div data-testid="separator">{children}</div>
-  ),
-}));
-
-function TestChild({ props }: WidgetProps) {
-  return <div data-testid="child">{String(props.label ?? '')}</div>;
-}
-
-beforeEach(() => {
-  clearWidgetRegistry();
-  registerWidget(
-    {
-      name: 'split',
-      label: 'Split',
-      category: 'layout',
-      schema: {},
-      binding: 'none',
-      triggers: [],
-      container: true,
-    },
-    SplitWidget as unknown as ComponentType<WidgetProps>,
-  );
-  registerWidget(
-    {
-      name: 'test-child',
-      label: 'Test Child',
-      category: 'display',
-      schema: {},
-      binding: 'none',
-      triggers: [],
-      container: false,
-    },
-    TestChild,
-  );
-});
-
-afterEach(() => {
-  cleanup();
-  clearWidgetRegistry();
-});
-
-const makeChildNodes = (labels: string[]): WidgetNode[] =>
-  labels.map((label) => ({ type: 'test-child', props: { label } }));
-
-const defaultCtx = { record: {}, model: '', mode: 'view' as const };
-
-function renderSplit(props: Record<string, unknown>, childNodes: WidgetNode[]) {
-  const store = new StateStore();
-  return render(
-    <PageStateProvider value={store}>
-      <WidgetContextProvider value={defaultCtx}>
-        <SplitWidget
-          props={props}
-          bind={{ value: undefined }}
-          on={{}}
-          context={defaultCtx}
-          childNodes={childNodes}
-        />
-      </WidgetContextProvider>
-    </PageStateProvider>,
-  );
-}
-
-describe('SplitWidget', () => {
-  it('renders children in resizable panels', () => {
-    const { container } = renderSplit(
-      { sizes: [60, 40], direction: 'horizontal' },
-      makeChildNodes(['Left', 'Right']),
-    );
-
-    const panels = container.querySelectorAll('[data-testid="panel"]');
-    expect(panels).toHaveLength(2);
-    expect(panels[0].getAttribute('data-default-size')).toBe('60');
-    expect(panels[1].getAttribute('data-default-size')).toBe('40');
-  });
-
-  it('distributes equally when sizes not provided', () => {
-    const { container } = renderSplit({}, makeChildNodes(['A', 'B', 'C']));
-
-    const panels = container.querySelectorAll('[data-testid="panel"]');
-    expect(panels).toHaveLength(3);
-    const expectedSize = String(100 / 3);
-    expect(panels[0].getAttribute('data-default-size')).toBe(expectedSize);
-  });
-
-  it('renders with vertical orientation', () => {
-    const { container } = renderSplit(
-      { sizes: [50, 50], direction: 'vertical' },
-      makeChildNodes(['Top', 'Bottom']),
-    );
-
-    const panels = container.querySelectorAll('[data-testid="panel"]');
-    expect(panels).toHaveLength(2);
-  });
-
-  it('defaults to horizontal direction', () => {
-    const { container } = renderSplit({ sizes: [70, 30] }, makeChildNodes(['Left', 'Right']));
-
-    const panels = container.querySelectorAll('[data-testid="panel"]');
-    expect(panels).toHaveLength(2);
-  });
-
-  it('renders resize handles between panels', () => {
-    const { container } = renderSplit({ sizes: [25, 50, 25] }, makeChildNodes(['A', 'B', 'C']));
-
-    const separators = container.querySelectorAll('[data-testid="separator"]');
-    expect(separators).toHaveLength(2);
-  });
-});

package/src/widgets/__tests__/state-edge-cases.test.ts

@@ -1,118 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { StateStore } from '../state/store.js';
-
-describe('StateStore Edge Cases', () => {
-  test('set with undefined value', () => {
-    const store = new StateStore();
-    store.set('key', undefined);
-    expect(store.get('key')).toBeUndefined();
-  });
-
-  test('set distinguishes null from undefined', () => {
-    const store = new StateStore();
-    store.set('a', null);
-    store.set('b', undefined);
-    expect(store.get('a')).toBeNull();
-    expect(store.get('b')).toBeUndefined();
-  });
-
-  test('multiple subscribers on same key all fire', () => {
-    const store = new StateStore();
-    const calls1: unknown[] = [];
-    const calls2: unknown[] = [];
-    store.subscribe('k', (v) => calls1.push(v));
-    store.subscribe('k', (v) => calls2.push(v));
-    store.set('k', 'hello');
-    expect(calls1).toEqual(['hello']);
-    expect(calls2).toEqual(['hello']);
-  });
-
-  test('subscriber added during notification fires on next change', () => {
-    const store = new StateStore();
-    const calls: unknown[] = [];
-    store.subscribe('k', () => {
-      store.subscribe('k', (v) => calls.push(v));
-    });
-    store.set('k', 1);
-    calls.length = 0;
-    store.set('k', 2);
-    expect(calls.length).toBeGreaterThanOrEqual(1);
-    expect(calls).toContain(2);
-  });
-
-  test('set with same reference value does not notify', () => {
-    const store = new StateStore();
-    const obj = { a: 1 };
-    store.set('k', obj);
-    const calls: unknown[] = [];
-    store.subscribe('k', (v) => calls.push(v));
-    store.set('k', obj);
-    expect(calls).toEqual([]);
-  });
-
-  test('set with different object reference does notify', () => {
-    const store = new StateStore();
-    store.set('k', { a: 1 });
-    const calls: unknown[] = [];
-    store.subscribe('k', (v) => calls.push(v));
-    store.set('k', { a: 1 });
-    expect(calls).toHaveLength(1);
-  });
-
-  test('setMany with all unchanged keys does not notify', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    store.set('b', 2);
-    const calls: unknown[] = [];
-    store.subscribe('a', (v) => calls.push(v));
-    store.subscribe('b', (v) => calls.push(v));
-    store.setMany({ a: 1, b: 2 });
-    expect(calls).toEqual([]);
-  });
-
-  test('unsubscribe same function twice is safe', () => {
-    const store = new StateStore();
-    const fn = () => {};
-    const unsub = store.subscribe('k', fn);
-    unsub();
-    unsub();
-    store.set('k', 1);
-  });
-
-  test('keys after clear is empty', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    store.set('b', 2);
-    store.clear();
-    expect(store.keys()).toEqual([]);
-  });
-
-  test('set after clear works normally', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    store.clear();
-    store.set('a', 2);
-    expect(store.get('a')).toBe(2);
-  });
-
-  test('subscribe after clear works normally', () => {
-    const store = new StateStore();
-    store.subscribe('k', () => {});
-    store.clear();
-    const calls: unknown[] = [];
-    store.subscribe('k', (v) => calls.push(v));
-    store.set('k', 'new');
-    expect(calls).toEqual(['new']);
-  });
-
-  test('handles rapid set cycles', () => {
-    const store = new StateStore();
-    const calls: unknown[] = [];
-    store.subscribe('counter', (v) => calls.push(v));
-    for (let i = 0; i < 100; i++) {
-      store.set('counter', i);
-    }
-    expect(calls).toHaveLength(100);
-    expect(calls[99]).toBe(99);
-  });
-});

package/src/widgets/__tests__/state.test.ts

@@ -1,106 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { StateStore } from '../state/store.js';
-
-describe('StateStore', () => {
-  test('get returns undefined for unset key', () => {
-    const store = new StateStore();
-    expect(store.get('missing')).toBeUndefined();
-  });
-
-  test('set and get a value', () => {
-    const store = new StateStore();
-    store.set('step', 1);
-    expect(store.get('step')).toBe(1);
-  });
-
-  test('set overwrites existing value', () => {
-    const store = new StateStore();
-    store.set('step', 1);
-    store.set('step', 2);
-    expect(store.get('step')).toBe(2);
-  });
-
-  test('subscribe is called on change', () => {
-    const store = new StateStore();
-    const calls: unknown[] = [];
-    store.subscribe('step', (v) => calls.push(v));
-    store.set('step', 1);
-    store.set('step', 2);
-    expect(calls).toEqual([1, 2]);
-  });
-
-  test('subscribe is not called when value unchanged', () => {
-    const store = new StateStore();
-    store.set('step', 1);
-    const calls: unknown[] = [];
-    store.subscribe('step', (v) => calls.push(v));
-    store.set('step', 1);
-    expect(calls).toEqual([]);
-  });
-
-  test('unsubscribe stops notifications', () => {
-    const store = new StateStore();
-    const calls: unknown[] = [];
-    const unsub = store.subscribe('step', (v) => calls.push(v));
-    store.set('step', 1);
-    unsub();
-    store.set('step', 2);
-    expect(calls).toEqual([1]);
-  });
-
-  test('setMany updates multiple keys', () => {
-    const store = new StateStore();
-    store.setMany({ step: 1, loading: true });
-    expect(store.get('step')).toBe(1);
-    expect(store.get('loading')).toBe(true);
-  });
-
-  test('setMany notifies subscribers for each changed key', () => {
-    const store = new StateStore();
-    const stepCalls: unknown[] = [];
-    const loadingCalls: unknown[] = [];
-    store.subscribe('step', (v) => stepCalls.push(v));
-    store.subscribe('loading', (v) => loadingCalls.push(v));
-    store.setMany({ step: 1, loading: true });
-    expect(stepCalls).toEqual([1]);
-    expect(loadingCalls).toEqual([true]);
-  });
-
-  test('setMany skips unchanged keys', () => {
-    const store = new StateStore();
-    store.set('step', 1);
-    const calls: unknown[] = [];
-    store.subscribe('step', (v) => calls.push(v));
-    store.setMany({ step: 1, loading: true });
-    expect(calls).toEqual([]);
-  });
-
-  test('writing one key does not affect others', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    store.set('b', 2);
-    const calls: unknown[] = [];
-    store.subscribe('b', (v) => calls.push(v));
-    store.set('a', 10);
-    expect(calls).toEqual([]);
-    expect(store.get('b')).toBe(2);
-  });
-
-  test('clear removes all state and subscribers', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    const calls: unknown[] = [];
-    store.subscribe('a', (v) => calls.push(v));
-    store.clear();
-    expect(store.get('a')).toBeUndefined();
-    store.set('a', 2);
-    expect(calls).toEqual([]);
-  });
-
-  test('keys returns all set keys', () => {
-    const store = new StateStore();
-    store.set('a', 1);
-    store.set('b', 2);
-    expect(store.keys().sort()).toEqual(['a', 'b']);
-  });
-});