@rangka/client 0.1.0 → 0.1.2

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

@@ -1,236 +0,0 @@
-import { describe, test, expect, vi } from 'vitest';
-import { dispatch } from '../action/dispatcher.js';
-import { StateStore } from '../state/store.js';
-import { createRootContext } from '../context/builder.js';
-import type { ActionContext, ActionHandlers } from '../action/dispatcher.js';
-
-function makeActionCtx(record: Record<string, unknown> = {}): ActionContext {
-  return {
-    widgetContext: createRootContext(record, 'sales.order', 'edit'),
-    state: new StateStore(),
-  };
-}
-
-describe('Action Dispatcher', () => {
-  describe('setValue', () => {
-    test('sets record field via handler', async () => {
-      const sets: [string, unknown][] = [];
-      const handlers: ActionHandlers = { setRecordValue: (f, v) => sets.push([f, v]) };
-      const ctx = makeActionCtx({ qty: 5, rate: 100 });
-      await dispatch({ type: 'setValue', field: 'qty', value: 10 }, ctx, handlers);
-      expect(sets).toEqual([['qty', 10]]);
-    });
-
-    test('sets $state key', async () => {
-      const ctx = makeActionCtx();
-      await dispatch({ type: 'setValue', field: '$state.step', value: 2 }, ctx, {});
-      expect(ctx.state.get('step')).toBe(2);
-    });
-
-    test('resolves expression in value', async () => {
-      const sets: [string, unknown][] = [];
-      const handlers: ActionHandlers = { setRecordValue: (f, v) => sets.push([f, v]) };
-      const ctx = makeActionCtx({ qty: 5, rate: 100 });
-      await dispatch({ type: 'setValue', field: 'amount', value: '{{qty * rate}}' }, ctx, handlers);
-      expect(sets).toEqual([['amount', 500]]);
-    });
-  });
-
-  describe('clearValue', () => {
-    test('sets field to null', async () => {
-      const sets: [string, unknown][] = [];
-      const handlers: ActionHandlers = { setRecordValue: (f, v) => sets.push([f, v]) };
-      await dispatch({ type: 'clearValue', field: 'name' }, makeActionCtx(), handlers);
-      expect(sets).toEqual([['name', null]]);
-    });
-  });
-
-  describe('setValues', () => {
-    test('sets multiple fields', async () => {
-      const sets: [string, unknown][] = [];
-      const handlers: ActionHandlers = { setRecordValue: (f, v) => sets.push([f, v]) };
-      const ctx = makeActionCtx();
-      await dispatch(
-        { type: 'setValues', values: { status: 'submitted', '$state.loading': true } },
-        ctx,
-        handlers,
-      );
-      expect(sets).toEqual([['status', 'submitted']]);
-      expect(ctx.state.get('loading')).toBe(true);
-    });
-  });
-
-  describe('navigate', () => {
-    test('calls navigate handler with resolved path', async () => {
-      const paths: string[] = [];
-      const handlers: ActionHandlers = { navigate: (p) => paths.push(p) };
-      const ctx = makeActionCtx({ id: '42' });
-      await dispatch({ type: 'navigate', path: '/orders/{{id}}' }, ctx, handlers);
-      expect(paths).toEqual(['/orders/42']);
-    });
-  });
-
-  describe('service', () => {
-    test('calls service and runs onSuccess', async () => {
-      const serviceCall = vi.fn().mockResolvedValue({ price: 99 });
-      const sets: [string, unknown][] = [];
-      const handlers: ActionHandlers = {
-        service: serviceCall,
-        setRecordValue: (f, v) => sets.push([f, v]),
-      };
-      const ctx = makeActionCtx({ product_id: 'P1' });
-      await dispatch(
-        {
-          type: 'service',
-          name: 'sales.getPrice',
-          params: { id: '{{product_id}}' },
-          onSuccess: { type: 'setValue', field: 'rate', value: '{{$response.price}}' },
-        },
-        ctx,
-        handlers,
-      );
-      expect(serviceCall).toHaveBeenCalledWith('sales.getPrice', { id: 'P1' });
-      expect(sets).toEqual([['rate', 99]]);
-    });
-
-    test('calls onError on failure', async () => {
-      const serviceCall = vi.fn().mockRejectedValue(new Error('Network error'));
-      const ctx = makeActionCtx();
-      const handlers: ActionHandlers = { service: serviceCall };
-      await dispatch(
-        {
-          type: 'service',
-          name: 'sales.submit',
-          onError: { type: 'setValue', field: '$state.error', value: '{{$response.message}}' },
-        },
-        ctx,
-        handlers,
-      );
-      expect(ctx.state.get('error')).toBe('Network error');
-    });
-
-    test('refreshes source by default on success without onSuccess', async () => {
-      const serviceCall = vi.fn().mockResolvedValue({});
-      const refreshSource = vi.fn();
-      const handlers: ActionHandlers = { service: serviceCall, refreshSource };
-      await dispatch({ type: 'service', name: 'sales.submit' }, makeActionCtx(), handlers);
-      expect(refreshSource).toHaveBeenCalled();
-    });
-  });
-
-  describe('model actions', () => {
-    test('model.create resolves expressions in data', async () => {
-      const modelCreate = vi.fn().mockResolvedValue({});
-      const handlers: ActionHandlers = { modelCreate };
-      const ctx = makeActionCtx({ customer: 'CUST-001' });
-      await dispatch(
-        { type: 'model.create', model: 'sales.order', data: { customer_id: '{{customer}}' } },
-        ctx,
-        handlers,
-      );
-      expect(modelCreate).toHaveBeenCalledWith('sales.order', { customer_id: 'CUST-001' });
-    });
-
-    test('model.update infers model and id from context', async () => {
-      const modelUpdate = vi.fn().mockResolvedValue({});
-      const handlers: ActionHandlers = { modelUpdate };
-      const ctx = makeActionCtx({ id: '42', status: 'draft' });
-      await dispatch({ type: 'model.update', data: { status: 'submitted' } }, ctx, handlers);
-      expect(modelUpdate).toHaveBeenCalledWith('sales.order', '42', { status: 'submitted' });
-    });
-
-    test('model.delete infers model and id from context', async () => {
-      const modelDelete = vi.fn().mockResolvedValue(undefined);
-      const handlers: ActionHandlers = { modelDelete };
-      const ctx = makeActionCtx({ id: '42' });
-      await dispatch({ type: 'model.delete' }, ctx, handlers);
-      expect(modelDelete).toHaveBeenCalledWith('sales.order', '42');
-    });
-  });
-
-  describe('sequence', () => {
-    test('runs actions in order', async () => {
-      const order: string[] = [];
-      const handlers: ActionHandlers = {
-        setRecordValue: (f) => order.push(f),
-      };
-      const ctx = makeActionCtx();
-      await dispatch(
-        {
-          type: 'sequence',
-          actions: [
-            { type: 'setValue', field: 'a', value: 1 },
-            { type: 'setValue', field: 'b', value: 2 },
-            { type: 'setValue', field: 'c', value: 3 },
-          ],
-        },
-        ctx,
-        handlers,
-      );
-      expect(order).toEqual(['a', 'b', 'c']);
-    });
-  });
-
-  describe('conditional', () => {
-    test('runs then branch when condition passes', async () => {
-      const ctx = makeActionCtx({ status: 'draft' });
-      await dispatch(
-        {
-          type: 'conditional',
-          condition: { field: 'status', operator: 'eq', value: 'draft' },
-          then: { type: 'setValue', field: '$state.canEdit', value: true },
-        },
-        ctx,
-        {},
-      );
-      expect(ctx.state.get('canEdit')).toBe(true);
-    });
-
-    test('runs else branch when condition fails', async () => {
-      const ctx = makeActionCtx({ status: 'submitted' });
-      await dispatch(
-        {
-          type: 'conditional',
-          condition: { field: 'status', operator: 'eq', value: 'draft' },
-          then: { type: 'setValue', field: '$state.canEdit', value: true },
-          else: { type: 'setValue', field: '$state.canEdit', value: false },
-        },
-        ctx,
-        {},
-      );
-      expect(ctx.state.get('canEdit')).toBe(false);
-    });
-  });
-
-  describe('simple handlers', () => {
-    test('refreshSource calls handler', async () => {
-      const refreshSource = vi.fn();
-      await dispatch({ type: 'refreshSource' }, makeActionCtx(), { refreshSource });
-      expect(refreshSource).toHaveBeenCalled();
-    });
-
-    test('focus calls handler', async () => {
-      const focus = vi.fn();
-      await dispatch({ type: 'focus', field: 'name' }, makeActionCtx(), { focus });
-      expect(focus).toHaveBeenCalledWith('name');
-    });
-
-    test('addRow calls handler', async () => {
-      const addRow = vi.fn();
-      await dispatch({ type: 'addRow', field: 'items' }, makeActionCtx(), { addRow });
-      expect(addRow).toHaveBeenCalledWith('items');
-    });
-
-    test('removeRow calls handler', async () => {
-      const removeRow = vi.fn();
-      await dispatch({ type: 'removeRow', field: 'items' }, makeActionCtx(), { removeRow });
-      expect(removeRow).toHaveBeenCalledWith('items');
-    });
-
-    test('duplicateRow calls handler', async () => {
-      const duplicateRow = vi.fn();
-      await dispatch({ type: 'duplicateRow', field: 'items' }, makeActionCtx(), { duplicateRow });
-      expect(duplicateRow).toHaveBeenCalledWith('items');
-    });
-  });
-});

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

@@ -1,85 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import React from 'react';
-import { render, screen, fireEvent, cleanup } from '@testing-library/react';
-import { AttachmentWidget } from '../components/AttachmentWidget.js';
-
-const defaultProps = {
-  props: {},
-  bind: { value: null },
-  on: {},
-  context: { record: {}, model: '', mode: 'view' as const },
-};
-
-afterEach(() => cleanup());
-
-describe('AttachmentWidget', () => {
-  it('renders upload zone when no file', () => {
-    render(<AttachmentWidget {...defaultProps} />);
-    expect(screen.getByText('Drop a file here or click to browse')).toBeInTheDocument();
-  });
-
-  it('displays label from props', () => {
-    render(<AttachmentWidget {...defaultProps} props={{ label: 'Logo' }} />);
-    expect(screen.getByText('Logo')).toBeInTheDocument();
-  });
-
-  it('shows file name when value is set', () => {
-    render(
-      <AttachmentWidget {...defaultProps} bind={{ value: { name: 'report.pdf', size: 2048 } }} />,
-    );
-    expect(screen.getByText('report.pdf')).toBeInTheDocument();
-  });
-
-  it('shows file size', () => {
-    render(
-      <AttachmentWidget {...defaultProps} bind={{ value: { name: 'report.pdf', size: 2048 } }} />,
-    );
-    expect(screen.getByText('2.0 KB')).toBeInTheDocument();
-  });
-
-  it('shows remove button when file exists', () => {
-    render(
-      <AttachmentWidget {...defaultProps} bind={{ value: { name: 'report.pdf', size: 1024 } }} />,
-    );
-    expect(screen.getByLabelText('Remove file')).toBeInTheDocument();
-  });
-
-  it('fires on.remove when removing file', () => {
-    const onRemove = vi.fn();
-    const setValue = vi.fn();
-    render(
-      <AttachmentWidget
-        {...defaultProps}
-        bind={{ value: { name: 'x.pdf', size: 100 }, setValue }}
-        on={{ remove: onRemove }}
-      />,
-    );
-    fireEvent.click(screen.getByLabelText('Remove file'));
-    expect(onRemove).toHaveBeenCalled();
-    expect(setValue).toHaveBeenCalledWith(null);
-  });
-
-  it('handles disabled state - no upload zone click', () => {
-    render(<AttachmentWidget {...defaultProps} props={{ disabled: true }} />);
-    const zone = screen.getByRole('button', { name: 'Upload file' });
-    expect(zone.className).toContain('cursor-not-allowed');
-  });
-
-  it('handles null bind.value gracefully', () => {
-    render(<AttachmentWidget {...defaultProps} bind={{ value: null }} />);
-    expect(screen.getByText('Drop a file here or click to browse')).toBeInTheDocument();
-  });
-
-  it('falls back to bind.meta.label', () => {
-    render(
-      <AttachmentWidget
-        {...defaultProps}
-        bind={{
-          value: null,
-          meta: { type: 'attachment', label: 'Document', required: false, readOnly: false },
-        }}
-      />,
-    );
-    expect(screen.getByText('Document')).toBeInTheDocument();
-  });
-});

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

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import React from 'react';
-import { render, screen, fireEvent, cleanup } from '@testing-library/react';
-import { AttachmentsWidget } from '../components/AttachmentsWidget.js';
-
-const defaultProps = {
-  props: {},
-  bind: { value: [] },
-  on: {},
-  context: { record: {}, model: '', mode: 'view' as const },
-};
-
-afterEach(() => cleanup());
-
-describe('AttachmentsWidget', () => {
-  it('renders upload zone when no files', () => {
-    render(<AttachmentsWidget {...defaultProps} />);
-    expect(screen.getByText(/Drop files here/)).toBeInTheDocument();
-  });
-
-  it('displays label from props', () => {
-    render(<AttachmentsWidget {...defaultProps} props={{ label: 'Documents' }} />);
-    expect(screen.getByText('Documents')).toBeInTheDocument();
-  });
-
-  it('shows file list when files exist', () => {
-    render(
-      <AttachmentsWidget
-        {...defaultProps}
-        bind={{
-          value: [
-            { name: 'a.pdf', size: 1024 },
-            { name: 'b.pdf', size: 2048 },
-          ],
-        }}
-      />,
-    );
-    expect(screen.getByText('a.pdf')).toBeInTheDocument();
-    expect(screen.getByText('b.pdf')).toBeInTheDocument();
-  });
-
-  it('shows file sizes', () => {
-    render(
-      <AttachmentsWidget {...defaultProps} bind={{ value: [{ name: 'a.pdf', size: 2048 }] }} />,
-    );
-    expect(screen.getByText('2.0 KB')).toBeInTheDocument();
-  });
-
-  it('shows remove button per file', () => {
-    render(
-      <AttachmentsWidget {...defaultProps} bind={{ value: [{ name: 'a.pdf', size: 100 }] }} />,
-    );
-    expect(screen.getByLabelText('Remove a.pdf')).toBeInTheDocument();
-  });
-
-  it('fires on.remove with index when removing', () => {
-    const onRemove = vi.fn();
-    const setValue = vi.fn();
-    render(
-      <AttachmentsWidget
-        {...defaultProps}
-        bind={{
-          value: [
-            { name: 'a.pdf', size: 100 },
-            { name: 'b.pdf', size: 200 },
-          ],
-          setValue,
-        }}
-        on={{ remove: onRemove }}
-      />,
-    );
-    fireEvent.click(screen.getByLabelText('Remove b.pdf'));
-    expect(onRemove).toHaveBeenCalledWith(1);
-    expect(setValue).toHaveBeenCalledWith([{ name: 'a.pdf', size: 100 }]);
-  });
-
-  it('shows count in upload zone', () => {
-    render(
-      <AttachmentsWidget
-        {...defaultProps}
-        props={{ maxCount: 5 }}
-        bind={{ value: [{ name: 'a.pdf', size: 100 }] }}
-      />,
-    );
-    expect(screen.getByText(/1\/5/)).toBeInTheDocument();
-  });
-
-  it('hides upload zone when max reached', () => {
-    render(
-      <AttachmentsWidget
-        {...defaultProps}
-        props={{ maxCount: 1 }}
-        bind={{ value: [{ name: 'a.pdf', size: 100 }] }}
-      />,
-    );
-    expect(screen.queryByRole('button', { name: 'Upload files' })).not.toBeInTheDocument();
-  });
-
-  it('handles disabled state', () => {
-    render(<AttachmentsWidget {...defaultProps} props={{ disabled: true }} />);
-    const zone = screen.getByRole('button', { name: 'Upload files' });
-    expect(zone.className).toContain('cursor-not-allowed');
-  });
-
-  it('handles null bind.value gracefully', () => {
-    render(<AttachmentsWidget {...defaultProps} bind={{ value: null }} />);
-    expect(screen.getByText(/Drop files here/)).toBeInTheDocument();
-  });
-});

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

@@ -1,76 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { resolveBinding } from '../binding/resolver.js';
-import { createRootContext } from '../context/builder.js';
-import type { FieldMeta } from '../binding/resolver.js';
-
-describe('Binding Resolver', () => {
-  const ctx = createRootContext(
-    { id: '1', customer_id: 'CUST-001', qty: 5, rate: 100, name: 'Test Order' },
-    'sales.order',
-    'edit',
-  );
-
-  const fieldMeta: Record<string, FieldMeta> = {
-    customer_id: { type: 'link', label: 'Customer', required: true, readOnly: false },
-    qty: { type: 'int', label: 'Quantity', required: true, readOnly: false },
-    name: { type: 'string', label: 'Order Name', required: false, readOnly: false },
-  };
-
-  test('returns null when no binding', () => {
-    expect(resolveBinding(undefined, ctx)).toBeNull();
-  });
-
-  test('field binding returns value from context', () => {
-    const result = resolveBinding({ field: 'customer_id' }, ctx, fieldMeta);
-    expect(result).not.toBeNull();
-    expect(result!.value).toBe('CUST-001');
-  });
-
-  test('field binding returns metadata', () => {
-    const result = resolveBinding({ field: 'customer_id' }, ctx, fieldMeta);
-    expect(result!.meta).toEqual({
-      type: 'link',
-      label: 'Customer',
-      required: true,
-      readOnly: false,
-    });
-  });
-
-  test('field binding provides setValue when handler given', () => {
-    const sets: [string, unknown][] = [];
-    const setter = (field: string, val: unknown) => sets.push([field, val]);
-    const result = resolveBinding({ field: 'qty' }, ctx, fieldMeta, setter);
-    expect(result!.setValue).toBeDefined();
-    result!.setValue!(10);
-    expect(sets).toEqual([['qty', 10]]);
-  });
-
-  test('field binding without setter has no setValue', () => {
-    const result = resolveBinding({ field: 'qty' }, ctx, fieldMeta);
-    expect(result!.setValue).toBeUndefined();
-  });
-
-  test('expression binding evaluates expression', () => {
-    const result = resolveBinding({ expression: '{{qty * rate}}' }, ctx);
-    expect(result!.value).toBe(500);
-  });
-
-  test('expression binding has no setValue', () => {
-    const result = resolveBinding({ expression: '{{qty * rate}}' }, ctx);
-    expect(result!.setValue).toBeUndefined();
-  });
-
-  test('model binding returns query config', () => {
-    const result = resolveBinding(
-      { model: { name: 'sales.order', filters: { status: 'draft' }, limit: 10 } },
-      ctx,
-    );
-    expect(result!.query).toEqual({ name: 'sales.order', filters: { status: 'draft' }, limit: 10 });
-    expect(result!.value).toBeNull();
-  });
-
-  test('field binding returns undefined for missing field', () => {
-    const result = resolveBinding({ field: 'missing' }, ctx, fieldMeta);
-    expect(result!.value).toBeUndefined();
-  });
-});

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

@@ -1,145 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import React from 'react';
-import { render, screen, fireEvent, cleanup } from '@testing-library/react';
-import { ButtonWidget } from '../components/ButtonWidget.js';
-
-afterEach(() => {
-  cleanup();
-});
-
-function renderButton(
-  overrides: {
-    props?: Record<string, unknown>;
-    on?: Record<string, (...args: unknown[]) => void>;
-  } = {},
-) {
-  const defaultProps = {
-    props: { label: 'Click me', ...overrides.props },
-    bind: { value: undefined },
-    on: { click: vi.fn(), ...overrides.on },
-    context: { record: {}, model: '', mode: 'view' as const },
-  };
-
-  return { ...render(<ButtonWidget {...defaultProps} />), on: defaultProps.on };
-}
-
-describe('ButtonWidget', () => {
-  describe('rendering', () => {
-    it('renders with label text', () => {
-      renderButton({ props: { label: 'Save' } });
-      expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument();
-    });
-
-    it('renders default button without crashing', () => {
-      renderButton();
-      expect(screen.getByRole('button', { name: 'Click me' })).toBeInTheDocument();
-    });
-  });
-
-  describe('variants', () => {
-    it('renders primary variant (maps to default)', () => {
-      renderButton({ props: { variant: 'primary' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('bg-primary');
-    });
-
-    it('renders secondary variant', () => {
-      renderButton({ props: { variant: 'secondary' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('bg-secondary');
-    });
-
-    it('renders ghost variant', () => {
-      renderButton({ props: { variant: 'ghost' } });
-      const button = screen.getByRole('button');
-      expect(button.className).not.toContain('bg-primary');
-      expect(button.className).not.toContain('bg-destructive');
-    });
-
-    it('renders destructive variant', () => {
-      renderButton({ props: { variant: 'destructive' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('destructive');
-    });
-  });
-
-  describe('sizes', () => {
-    it('renders sm size', () => {
-      renderButton({ props: { size: 'sm' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('h-7');
-    });
-
-    it('renders default size', () => {
-      renderButton({ props: { size: 'md' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('h-8');
-    });
-
-    it('renders lg size', () => {
-      renderButton({ props: { size: 'lg' } });
-      const button = screen.getByRole('button');
-      expect(button.className).toContain('h-9');
-    });
-  });
-
-  describe('disabled', () => {
-    it('disables the button when disabled prop is true', () => {
-      renderButton({ props: { disabled: true } });
-      const button = screen.getByRole('button');
-      expect(button).toBeDisabled();
-    });
-
-    it('button is not disabled by default', () => {
-      renderButton();
-      const button = screen.getByRole('button');
-      expect(button).not.toBeDisabled();
-    });
-  });
-
-  describe('click trigger', () => {
-    it('fires on.click handler when clicked', () => {
-      const { on } = renderButton();
-      const button = screen.getByRole('button');
-
-      fireEvent.click(button);
-
-      expect(on.click).toHaveBeenCalledTimes(1);
-    });
-
-    it('does not fire on.click when disabled', () => {
-      const { on } = renderButton({ props: { disabled: true } });
-      const button = screen.getByRole('button');
-
-      fireEvent.click(button);
-
-      expect(on.click).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('widgetMeta', () => {
-    it('has correct meta name', () => {
-      expect(ButtonWidget.widgetMeta.name).toBe('button');
-    });
-
-    it('has correct category', () => {
-      expect(ButtonWidget.widgetMeta.category).toBe('action');
-    });
-
-    it('declares click trigger', () => {
-      expect(ButtonWidget.widgetMeta.triggers).toContain('click');
-    });
-
-    it('is not a container', () => {
-      expect(ButtonWidget.widgetMeta.container).toBe(false);
-    });
-
-    it('has binding type none', () => {
-      expect(ButtonWidget.widgetMeta.binding).toBe('none');
-    });
-
-    it('requires label in schema', () => {
-      expect(ButtonWidget.widgetMeta.schema.label.required).toBe(true);
-    });
-  });
-});