@mindlogic-ai/logician-ui 4.0.0-alpha.8 → 4.0.0

package/src/components/Form/FieldRow/FieldRow.types.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+
+import { FormControlProps } from '@/components/FormControl';
+
+import { FieldLabelProps } from '../FieldLabel';
+
+export interface FieldRowProps extends Omit<FormControlProps, 'label'> {
+  /** Field label heading. Omit for an unlabeled control row. */
+  label?: ReactNode;
+  /** Secondary description rendered under the label. */
+  description?: ReactNode;
+  /**
+   * Inline node at the right of the label row — a count badge, an action
+   * button, or a logician `InfoSprinkle` help popover.
+   */
+  endAdornment?: ReactNode;
+  /** Always-visible helper text rendered under the control. */
+  helperText?: ReactNode;
+  /**
+   * Error message. When set (and `invalid` is not explicitly overridden) the
+   * field renders as invalid, so the control gets `aria-invalid` and the error
+   * is announced and associated via `aria-describedby`.
+   */
+  error?: ReactNode;
+  /** The control (input/select/switch/…) this row wraps. */
+  children: ReactNode;
+  /** Extra props forwarded to the inner `FieldLabel` (e.g. custom `mb`). */
+  labelProps?: Omit<
+    FieldLabelProps,
+    'heading' | 'description' | 'endAdornment'
+  >;
+}

package/src/components/Form/FieldRow/index.ts

@@ -0,0 +1,2 @@
+export { FieldRow } from './FieldRow';
+export type { FieldRowProps } from './FieldRow.types';

package/src/components/Form/FormFooter/FormFooter.stories.tsx

@@ -0,0 +1,70 @@
+import { Box } from '@chakra-ui/react';
+import { Meta, StoryObj } from '@storybook/react';
+
+import { Button } from '@/components/Button';
+import { Subtitle } from '@/components/Typography';
+
+import { FormFooter } from './FormFooter';
+
+const meta: Meta<typeof FormFooter> = {
+  title: 'Components/Form/FormFooter',
+  component: FormFooter,
+  decorators: [
+    (Story) => (
+      <Box w="420px" bg="bg.canvas">
+        <Story />
+      </Box>
+    ),
+  ],
+  parameters: {
+    docs: {
+      description: {
+        component:
+          'The sticky footer shell shared by the studio settings footer and ' +
+          'the image/video generation footers: an optional left `start` slot ' +
+          'against a right group of `meta` + `action`.',
+      },
+    },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof FormFooter>;
+
+/** Studio settings footer shape: destructive start + saved-at meta + save action. */
+export const WithStartMetaAndAction: Story = {
+  args: {
+    start: (
+      <Button size="sm" variant="ghost" colorPalette="danger">
+        Delete
+      </Button>
+    ),
+    meta: <Subtitle>Updated 2 minutes ago</Subtitle>,
+    action: (
+      <Button size="sm" variant="solid">
+        Save
+      </Button>
+    ),
+  },
+};
+
+/** Media generation footer shape: a single full-width action. */
+export const FullWidthAction: Story = {
+  args: {
+    action: (
+      <Button variant="solid" size="lg" w="100%">
+        Generate image · 12
+      </Button>
+    ),
+  },
+};
+
+export const ActionOnly: Story = {
+  args: {
+    action: (
+      <Button size="sm" variant="solid">
+        Save
+      </Button>
+    ),
+  },
+};

package/src/components/Form/FormFooter/FormFooter.test.tsx

@@ -0,0 +1,67 @@
+import type { ReactNode } from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { FormFooter } from './FormFooter';
+
+// Surface the layout-driving props (justify / position) onto the DOM so the
+// slot layout and sticky behavior are assertable without a Chakra provider.
+vi.mock('@chakra-ui/react', () => ({
+  Flex: ({
+    children,
+    justify,
+    position,
+  }: {
+    children?: ReactNode;
+    justify?: string;
+    position?: string;
+  }) => (
+    <div data-justify={justify ?? ''} data-position={position ?? ''}>
+      {children}
+    </div>
+  ),
+}));
+
+const outer = (container: HTMLElement) => container.firstChild as HTMLElement;
+
+describe('FormFooter', () => {
+  it('renders start, meta and action slots', () => {
+    render(
+      <FormFooter
+        start={<button>Delete</button>}
+        meta={<span>Updated now</span>}
+        action={<button>Save</button>}
+      />
+    );
+    expect(screen.getByText('Delete')).toBeInTheDocument();
+    expect(screen.getByText('Updated now')).toBeInTheDocument();
+    expect(screen.getByText('Save')).toBeInTheDocument();
+  });
+
+  it('justifies space-between when a start slot is present', () => {
+    const { container } = render(
+      <FormFooter
+        start={<button>Delete</button>}
+        action={<button>Save</button>}
+      />
+    );
+    expect(outer(container)).toHaveAttribute('data-justify', 'space-between');
+  });
+
+  it('justifies flex-end when there is no start slot (media full-width action)', () => {
+    const { container } = render(
+      <FormFooter action={<button>Generate</button>} />
+    );
+    expect(outer(container)).toHaveAttribute('data-justify', 'flex-end');
+  });
+
+  it('is sticky by default and drops sticky when disabled', () => {
+    const { container, rerender } = render(
+      <FormFooter action={<button>Save</button>} />
+    );
+    expect(outer(container)).toHaveAttribute('data-position', 'sticky');
+
+    rerender(<FormFooter action={<button>Save</button>} sticky={false} />);
+    expect(outer(container)).toHaveAttribute('data-position', '');
+  });
+});

package/src/components/Form/FormFooter/FormFooter.tsx

@@ -0,0 +1,46 @@
+import { Flex } from '@chakra-ui/react';
+
+import { FormFooterProps } from './FormFooter.types';
+
+/**
+ * The sticky footer shell shared by the form-in-sidebar surfaces — the studio
+ * settings footer and the image/video generation footers. It standardizes the
+ * chrome (sticky bottom, `bg.surface`, hairline top border) and lays out an
+ * optional left `start` slot against a right group of `meta` + `action`. The
+ * action's own loading/disabled state lives on the button passed in, so this is
+ * a pure layout shell.
+ */
+export const FormFooter = ({
+  start,
+  meta,
+  action,
+  sticky = true,
+  ...rest
+}: FormFooterProps) => {
+  return (
+    <Flex
+      {...(sticky ? { position: 'sticky', bottom: 0 } : { flexShrink: 0 })}
+      p={4}
+      borderTopWidth="1px"
+      borderColor="border.subtle"
+      w="100%"
+      bgColor="bg.surface"
+      justify={start ? 'space-between' : 'flex-end'}
+      align="center"
+      {...rest}
+    >
+      {start}
+      {(meta != null || action != null) && (
+        <Flex
+          align="center"
+          justify="flex-end"
+          gap={4}
+          flex={start ? undefined : 1}
+        >
+          {meta}
+          {action}
+        </Flex>
+      )}
+    </Flex>
+  );
+};

package/src/components/Form/FormFooter/FormFooter.types.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { FlexProps } from '@chakra-ui/react';
+
+export interface FormFooterProps extends Omit<FlexProps, 'children'> {
+  /**
+   * Left-aligned slot — typically a destructive or back action (e.g. delete).
+   * When present the footer justifies its content `space-between`; otherwise the
+   * right group fills the width.
+   */
+  start?: ReactNode;
+  /**
+   * Right-aligned metadata rendered before the action — a saved-at timestamp or
+   * a credit cost.
+   */
+  meta?: ReactNode;
+  /** The primary action, right-aligned. */
+  action?: ReactNode;
+  /**
+   * Pin the footer to the bottom of its scroll container. Defaults to true; set
+   * false for a footer that flows at the end of non-scrolling content.
+   */
+  sticky?: boolean;
+}

package/src/components/Form/FormFooter/index.ts

@@ -0,0 +1,2 @@
+export { FormFooter } from './FormFooter';
+export type { FormFooterProps } from './FormFooter.types';

package/src/components/Form/FormModalFooter/FormModalFooter.stories.tsx

@@ -0,0 +1,64 @@
+import { Box } from '@chakra-ui/react';
+import { Meta, StoryObj } from '@storybook/react';
+
+import { FormModalFooter } from './FormModalFooter';
+
+const meta: Meta<typeof FormModalFooter> = {
+  title: 'Components/Form/FormModalFooter',
+  component: FormModalFooter,
+  args: {
+    onCancel: () => {},
+    onSubmit: () => {},
+    cancelLabel: 'Cancel',
+    submitLabel: 'Save',
+  },
+  decorators: [
+    (Story) => (
+      <Box w="480px" bg="bg.canvas">
+        <Story />
+      </Box>
+    ),
+  ],
+  parameters: {
+    docs: {
+      description: {
+        component:
+          'The action footer shared by form-in-a-modal surfaces — the form ' +
+          'analog of a confirm-modal footer. Standardizes the optional delete ' +
+          '+ Cancel + primary-submit trio every create/edit modal was ' +
+          'hand-rolling. Copy-agnostic: `cancelLabel` is required and labels ' +
+          'are rendered verbatim.',
+      },
+    },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof FormModalFooter>;
+
+/** The common shape: Cancel + primary submit. */
+export const Default: Story = {};
+
+/** Edit modal shape: a far-left destructive Delete beside Cancel + submit. */
+export const WithDelete: Story = {
+  args: {
+    onDelete: () => {},
+    deleteLabel: 'Delete',
+    submitLabel: 'Save changes',
+  },
+};
+
+/** Mid-request: spinner on submit, every button disabled. */
+export const Submitting: Story = {
+  args: { isSubmitting: true },
+};
+
+/** Gated submit (e.g. a required field is empty). */
+export const SubmitDisabled: Story = {
+  args: { submitDisabled: true },
+};
+
+/** Scroll-inside modal: the bordered separator against a pinned footer. */
+export const Bordered: Story = {
+  args: { bordered: true, onDelete: () => {}, deleteLabel: 'Delete' },
+};

package/src/components/Form/FormModalFooter/FormModalFooter.test.tsx

@@ -0,0 +1,155 @@
+import type { ReactNode } from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { FormModalFooter } from './FormModalFooter';
+
+// Surface the Button's type/disabled/loading onto the DOM so behavior is
+// testable without a Chakra provider. The copy-agnostic footer owns no
+// translations, so labels are passed explicitly by the caller.
+vi.mock('@/components/Modal', () => ({
+  ModalFooter: ({ children }: { children?: ReactNode }) => (
+    <div data-testid="footer">{children}</div>
+  ),
+}));
+
+vi.mock('@/components/Button', () => ({
+  Button: ({
+    children,
+    onClick,
+    type,
+    disabled,
+    loading,
+  }: {
+    children?: ReactNode;
+    onClick?: () => void;
+    type?: 'button' | 'submit';
+    disabled?: boolean;
+    loading?: boolean;
+  }) => (
+    <button
+      type={type}
+      onClick={onClick}
+      disabled={disabled}
+      data-loading={loading ? 'true' : 'false'}
+    >
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/Icon', () => ({
+  TrashIcon: () => <span data-testid="trash" />,
+}));
+
+const noop = () => {};
+
+describe('FormModalFooter', () => {
+  it('renders a Cancel + submit pair with the given labels', () => {
+    render(
+      <FormModalFooter
+        onCancel={noop}
+        onSubmit={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Cancel' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument();
+    // No delete button unless onDelete is provided.
+    expect(screen.queryByTestId('trash')).not.toBeInTheDocument();
+  });
+
+  it('routes cancel and submit clicks to their handlers', () => {
+    const onCancel = vi.fn();
+    const onSubmit = vi.fn();
+    render(
+      <FormModalFooter
+        onCancel={onCancel}
+        onSubmit={onSubmit}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+      />
+    );
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Save' }));
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it('is a type="submit" button inside a form (no onSubmit), type="button" with onSubmit', () => {
+    const { rerender } = render(
+      <FormModalFooter
+        onCancel={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Save' })).toHaveAttribute(
+      'type',
+      'submit'
+    );
+    rerender(
+      <FormModalFooter
+        onCancel={noop}
+        onSubmit={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Save' })).toHaveAttribute(
+      'type',
+      'button'
+    );
+  });
+
+  it('renders the standard delete button and routes its click', () => {
+    const onDelete = vi.fn();
+    render(
+      <FormModalFooter
+        onCancel={noop}
+        onSubmit={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+        onDelete={onDelete}
+        deleteLabel="Delete"
+      />
+    );
+    expect(screen.getByTestId('trash')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: /Delete/ }));
+    expect(onDelete).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables every button and shows the submit spinner while submitting', () => {
+    render(
+      <FormModalFooter
+        onCancel={noop}
+        onSubmit={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+        onDelete={noop}
+        deleteLabel="Delete"
+        isSubmitting
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Cancel' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: /Delete/ })).toBeDisabled();
+    const submit = screen.getByRole('button', { name: 'Save' });
+    expect(submit).toBeDisabled();
+    expect(submit).toHaveAttribute('data-loading', 'true');
+  });
+
+  it('disables only the submit button when submitDisabled is set', () => {
+    render(
+      <FormModalFooter
+        onCancel={noop}
+        onSubmit={noop}
+        cancelLabel="Cancel"
+        submitLabel="Save"
+        submitDisabled
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Save' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Cancel' })).not.toBeDisabled();
+  });
+});

package/src/components/Form/FormModalFooter/FormModalFooter.tsx

@@ -0,0 +1,83 @@
+import { Button } from '@/components/Button';
+import { TrashIcon } from '@/components/Icon';
+import { ModalFooter } from '@/components/Modal';
+
+import { FormModalFooterProps } from './FormModalFooter.types';
+
+/**
+ * The action footer shared by form-in-a-modal surfaces — the form analog of a
+ * confirm-modal footer. It standardizes the button trio every create/edit modal
+ * hand-rolls: an optional far-left destructive action, a neutral Cancel, and the
+ * primary submit that carries its own loading + disabled state.
+ *
+ * Copy-agnostic by design: as a design-system component it owns no strings, so
+ * `cancelLabel` is required and `deleteLabel` is rendered verbatim — the
+ * consuming app supplies its own (translated) labels.
+ *
+ * Submit path: inside a `<form onSubmit>` leave `onSubmit` unset so the button
+ * stays `type="submit"` (Enter submits); for a portaled or no-`<form>` modal
+ * pass `onSubmit` and it becomes a `type="button"` onClick. `...rest` forwards to
+ * the logician `ModalFooter`, so callers pin it (`position="sticky"` /
+ * `flexShrink={0}`) or zero its padding (`px={0}`) per modal.
+ */
+export const FormModalFooter = ({
+  onDelete,
+  deleteLabel,
+  onCancel,
+  cancelLabel,
+  submitLabel,
+  submitColorPalette = 'primary',
+  isSubmitting = false,
+  submitDisabled = false,
+  onSubmit,
+  bordered = false,
+  ...rest
+}: FormModalFooterProps) => {
+  return (
+    <ModalFooter
+      justifyContent="flex-end"
+      gap={2}
+      {...(bordered
+        ? {
+            bg: 'bg.surface',
+            borderTop: '1px solid',
+            borderColor: 'border.subtle',
+          }
+        : {})}
+      {...rest}
+    >
+      {onDelete && (
+        <Button
+          colorPalette="danger"
+          variant="solid"
+          type="button"
+          onClick={onDelete}
+          disabled={isSubmitting}
+          mr="auto"
+        >
+          <TrashIcon boxSize="sm" />
+          {deleteLabel}
+        </Button>
+      )}
+      <Button
+        colorPalette="neutral"
+        variant="outline"
+        type="button"
+        onClick={onCancel}
+        disabled={isSubmitting}
+      >
+        {cancelLabel}
+      </Button>
+      <Button
+        colorPalette={submitColorPalette}
+        variant="solid"
+        type={onSubmit ? 'button' : 'submit'}
+        onClick={onSubmit}
+        loading={isSubmitting}
+        disabled={isSubmitting || submitDisabled}
+      >
+        {submitLabel}
+      </Button>
+    </ModalFooter>
+  );
+};

package/src/components/Form/FormModalFooter/FormModalFooter.types.ts

@@ -0,0 +1,53 @@
+import { ComponentProps, ReactNode } from 'react';
+
+import { ButtonColorPalette } from '@/components/Button';
+import { ModalFooter } from '@/components/Modal';
+
+type ModalFooterProps = ComponentProps<typeof ModalFooter>;
+
+export interface FormModalFooterProps extends Omit<
+  ModalFooterProps,
+  'children' | 'onSubmit' | 'title'
+> {
+  /**
+   * Optional left-aligned destructive action. Renders the standard danger
+   * delete button (trash glyph + label), pushed to the far left of the footer.
+   */
+  onDelete?: () => void;
+  /** Delete button label. Rendered verbatim (no default — the app owns copy). */
+  deleteLabel?: ReactNode;
+  /** Cancel/dismiss handler. */
+  onCancel: () => void;
+  /**
+   * Cancel button label. Required — a design-system component owns no copy, so
+   * the consuming app must supply the (translated) label.
+   */
+  cancelLabel: ReactNode;
+  /** Primary submit button label. */
+  submitLabel: ReactNode;
+  /** Palette for the primary button. Defaults to `primary`. */
+  submitColorPalette?: ButtonColorPalette;
+  /**
+   * In-flight state — shows the submit spinner and disables every button so the
+   * modal can't be dismissed or re-submitted mid-request.
+   */
+  isSubmitting?: boolean;
+  /**
+   * Extra disable condition for the primary button beyond `isSubmitting` — a
+   * pristine/invalid gate (e.g. `!name.trim()`).
+   */
+  submitDisabled?: boolean;
+  /**
+   * Submit via `onClick` instead of native form submission. Pass this for a
+   * portaled or no-`<form>` modal, where a `type="submit"` button can't reach
+   * the enclosing `<form>`. Omit inside a `<form onSubmit>` so the button stays
+   * `type="submit"` and Enter still submits.
+   */
+  onSubmit?: () => void;
+  /**
+   * Draw the scroll-separator chrome (surface background + top hairline). Set on
+   * a tall scroll-inside modal so the pinned footer reads as separate from the
+   * scrolling body; omit on a short modal.
+   */
+  bordered?: boolean;
+}

package/src/components/Form/FormModalFooter/index.ts

@@ -0,0 +1,2 @@
+export { FormModalFooter } from './FormModalFooter';
+export type { FormModalFooterProps } from './FormModalFooter.types';

package/src/components/Form/FormScrollArea/FormScrollArea.tsx

@@ -0,0 +1,27 @@
+import { PropsWithChildren } from 'react';
+import { Box, BoxProps } from '@chakra-ui/react';
+
+/**
+ * The scrolling body of a form panel: a full-height flex column that scrolls
+ * vertically, so a `position="sticky" bottom={0}` `FormFooter` pins to its
+ * bottom edge. Extracted from `FloatingPanelCard` so the same "scroll column +
+ * pinned footer" geometry can back any left-panel form without pulling in the
+ * card chrome.
+ */
+export const FormScrollArea = ({
+  children,
+  ...rest
+}: PropsWithChildren<BoxProps>) => (
+  <Box
+    h="100%"
+    overflowY="auto"
+    position="relative"
+    display="flex"
+    flexDirection="column"
+    {...rest}
+  >
+    {children}
+  </Box>
+);
+
+FormScrollArea.displayName = 'FormScrollArea';

package/src/components/Form/FormScrollArea/index.ts

@@ -0,0 +1 @@
+export { FormScrollArea } from './FormScrollArea';

package/src/components/Form/FormSection/CollapsibleFormSection.tsx

@@ -0,0 +1,35 @@
+import { VStack } from '@chakra-ui/react';
+
+import { CollapsibleSection } from '@/components/Workflow';
+
+import { FormSectionProps } from './FormSection.types';
+
+type CollapsibleFormSectionProps = Pick<
+  FormSectionProps,
+  'title' | 'action' | 'defaultOpen' | 'hasError' | 'gap' | 'children'
+>;
+
+/**
+ * The collapsible `FormSection` variant — delegates to the logician
+ * `CollapsibleSection` accordion (which owns its own layout, so container style
+ * overrides apply to the flat variant only). Requires a title.
+ */
+export const CollapsibleFormSection = ({
+  title,
+  action,
+  defaultOpen = true,
+  hasError = false,
+  gap = 4,
+  children,
+}: CollapsibleFormSectionProps) => (
+  <CollapsibleSection
+    label={title ?? ''}
+    defaultExpanded={defaultOpen}
+    hasError={hasError}
+    headerAction={action}
+  >
+    <VStack align="stretch" gap={gap} w="100%">
+      {children}
+    </VStack>
+  </CollapsibleSection>
+);