@papernote/ui 1.1.0 → 1.2.0

package/src/components/CurrencyInput.tsx

@@ -0,0 +1,193 @@
+import React, { forwardRef, useState, useEffect } from 'react';
+import Input, { InputProps } from './Input';
+
+export interface CurrencyInputProps extends Omit<InputProps, 'type' | 'value' | 'onChange' | 'prefix'> {
+  /** Numeric value (not formatted) */
+  value?: number | string;
+  /** Callback when value changes (receives numeric value) */
+  onChange?: (value: number | null) => void;
+  /** Currency code (default: 'USD') */
+  currency?: string;
+  /** Locale for formatting (default: 'en-US') */
+  locale?: string;
+  /** Number of decimal places (default: 2) */
+  precision?: number;
+  /** Allow negative values (default: false) */
+  allowNegative?: boolean;
+  /** Minimum allowed value */
+  min?: number;
+  /** Maximum allowed value */
+  max?: number;
+}
+
+/**
+ * CurrencyInput - Specialized input for monetary values
+ *
+ * Automatically formats currency values with proper symbols and thousands separators.
+ * Handles parsing and validation of numeric currency input.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <CurrencyInput
+ *   label="Price"
+ *   value={price}
+ *   onChange={setPrice}
+ *   currency="USD"
+ * />
+ * ```
+ *
+ * @example With validation
+ * ```tsx
+ * <CurrencyInput
+ *   label="Budget"
+ *   value={budget}
+ *   onChange={setBudget}
+ *   min={0}
+ *   max={10000}
+ *   validationState={budget > 10000 ? 'error' : null}
+ *   validationMessage={budget > 10000 ? 'Exceeds maximum budget' : ''}
+ * />
+ * ```
+ */
+const CurrencyInput = forwardRef<HTMLInputElement, CurrencyInputProps>(
+  (
+    {
+      value,
+      onChange,
+      currency = 'USD',
+      locale = 'en-US',
+      precision = 2,
+      allowNegative = false,
+      min,
+      max,
+      onBlur,
+      onFocus,
+      ...props
+    },
+    ref
+  ) => {
+    const [displayValue, setDisplayValue] = useState('');
+    const [isFocused, setIsFocused] = useState(false);
+
+    // Get currency symbol
+    const getCurrencySymbol = () => {
+      const formatter = new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency,
+      });
+      const parts = formatter.formatToParts(0);
+      const symbolPart = parts.find(part => part.type === 'currency');
+      return symbolPart?.value || '$';
+    };
+
+    const currencySymbol = getCurrencySymbol();
+
+    // Format number as currency
+    const formatCurrency = (num: number): string => {
+      const formatter = new Intl.NumberFormat(locale, {
+        minimumFractionDigits: isFocused ? 0 : precision,
+        maximumFractionDigits: precision,
+      });
+      return formatter.format(num);
+    };
+
+    // Parse display value to number
+    const parseValue = (str: string): number | null => {
+      if (!str || str === '') return null;
+
+      // Remove all non-numeric characters except decimal point and minus sign
+      let cleaned = str.replace(/[^\d.-]/g, '');
+
+      // Handle multiple decimal points
+      const parts = cleaned.split('.');
+      if (parts.length > 2) {
+        cleaned = parts[0] + '.' + parts.slice(1).join('');
+      }
+
+      // Handle multiple minus signs (keep only first)
+      const minusCount = (cleaned.match(/-/g) || []).length;
+      if (minusCount > 1) {
+        const hasLeadingMinus = cleaned.startsWith('-');
+        cleaned = cleaned.replace(/-/g, '');
+        if (hasLeadingMinus) cleaned = '-' + cleaned;
+      }
+
+      // Parse to float
+      const num = parseFloat(cleaned);
+
+      if (isNaN(num)) return null;
+
+      // Apply precision
+      return Math.round(num * Math.pow(10, precision)) / Math.pow(10, precision);
+    };
+
+    // Update display value when external value changes
+    useEffect(() => {
+      if (value === undefined || value === null || value === '') {
+        setDisplayValue('');
+      } else {
+        const numValue = typeof value === 'string' ? parseFloat(value) : value;
+        if (!isNaN(numValue)) {
+          setDisplayValue(formatCurrency(numValue));
+        }
+      }
+    }, [value, isFocused]);
+
+    const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+      const inputValue = e.target.value;
+      setDisplayValue(inputValue);
+
+      const numValue = parseValue(inputValue);
+
+      // Validate constraints
+      if (numValue !== null) {
+        if (!allowNegative && numValue < 0) return;
+        if (min !== undefined && numValue < min) return;
+        if (max !== undefined && numValue > max) return;
+      }
+
+      onChange?.(numValue);
+    };
+
+    const handleFocus = (e: React.FocusEvent<HTMLInputElement>) => {
+      setIsFocused(true);
+      // Remove formatting when focused for easier editing
+      if (value !== undefined && value !== null && value !== '') {
+        const numValue = typeof value === 'string' ? parseFloat(value) : value;
+        if (!isNaN(numValue)) {
+          setDisplayValue(numValue.toString());
+        }
+      }
+      onFocus?.(e);
+    };
+
+    const handleBlur = (e: React.FocusEvent<HTMLInputElement>) => {
+      setIsFocused(false);
+      // Reformat on blur
+      const numValue = parseValue(displayValue);
+      if (numValue !== null) {
+        setDisplayValue(formatCurrency(numValue));
+      } else if (displayValue === '') {
+        setDisplayValue('');
+      }
+      onBlur?.(e);
+    };
+
+    return (
+      <Input
+        ref={ref}
+        type="text"
+        value={displayValue}
+        onChange={handleChange}
+        onFocus={handleFocus}
+        onBlur={handleBlur}
+        prefix={currencySymbol}
+        {...props}
+      />
+    );
+  }
+);
+
+CurrencyInput.displayName = 'CurrencyInput';
+
+export default CurrencyInput;

package/src/components/DataTable.tsx

@@ -2,6 +2,7 @@
 import React, { useState, useRef, useEffect } from 'react';
 import { createPortal } from 'react-dom';
 import { ChevronDown, ChevronRight, MoreVertical, Edit, Trash } from 'lucide-react';
+import Menu, { MenuItem } from './Menu';
 
 /**
  * Base data item interface - all data items must have an id
@@ -164,6 +165,8 @@ interface DataTableProps<T extends BaseDataItem = BaseDataItem> {
   onDelete?: (item: T) => void | Promise<void>;
   /** Optional custom row actions (in addition to edit/delete) */
   actions?: DataTableAction<T>[];
+  /** Enable context menu (right-click) for row actions (default: true when actions exist) */
+  enableContextMenu?: boolean;
   /** Optional click handler for rows */
   onRowClick?: (item: T) => void;
   /** Optional double-click handler for rows */
@@ -455,6 +458,7 @@ export default function DataTable<T extends BaseDataItem = BaseDataItem>({
   onEdit,
   onDelete,
   actions = [],
+  enableContextMenu = true,
   onRowClick,
   onRowDoubleClick,
   selectable = false,
@@ -505,6 +509,17 @@ export default function DataTable<T extends BaseDataItem = BaseDataItem>({
   // Row hover state (for coordinating primary + secondary row highlighting)
   const [hoveredRowKey, setHoveredRowKey] = useState<string | null>(null);
 
+  // Context menu state
+  const [contextMenuState, setContextMenuState] = useState<{
+    isOpen: boolean;
+    position: { x: number; y: number };
+    item: T | null;
+  }>({
+    isOpen: false,
+    position: { x: 0, y: 0 },
+    item: null,
+  });
+
   // Filter columns based on hiddenColumns
   const baseVisibleColumns = columns.filter(
     col => !hiddenColumns.includes(String(col.key))
@@ -757,7 +772,31 @@ export default function DataTable<T extends BaseDataItem = BaseDataItem>({
   }
   
   const allActions = [...builtInActions, ...actions];
-  
+
+  // Convert actions to menu items for context menu
+  const convertActionsToMenuItems = (item: T): MenuItem[] => {
+    const visibleActions = allActions.filter(action => !action.show || action.show(item));
+
+    return visibleActions.map((action, idx) => {
+      let iconElement: React.ReactNode = null;
+      if (action.icon) {
+        if (React.isValidElement(action.icon)) {
+          iconElement = action.icon;
+        } else {
+          iconElement = React.createElement(action.icon as any, { className: 'h-4 w-4' });
+        }
+      }
+
+      return {
+        id: `action-${idx}`,
+        label: action.label,
+        icon: iconElement,
+        onClick: () => action.onClick(item),
+        danger: action.variant === 'danger',
+      };
+    });
+  };
+
   // Selection state management
   const [internalSelectedRows, setInternalSelectedRows] = useState<Set<string>>(new Set());
   
@@ -997,6 +1036,21 @@ export default function DataTable<T extends BaseDataItem = BaseDataItem>({
           onMouseEnter={() => !disableHover && setHoveredRowKey(rowKey)}
           onMouseLeave={() => !disableHover && setHoveredRowKey(null)}
           onClick={() => onRowClick?.(item)}
+          onContextMenu={(e) => {
+            if (enableContextMenu && allActions.length > 0) {
+              e.preventDefault();
+              e.stopPropagation();
+
+              const x = e.clientX;
+              const y = e.clientY;
+
+              setContextMenuState({
+                isOpen: true,
+                position: { x, y },
+                item,
+              });
+            }
+          }}
           onDoubleClick={() => {
             // Priority 1: If there's an onEdit handler (legacy), trigger it
             if (onEdit) {
@@ -1382,18 +1436,28 @@ export default function DataTable<T extends BaseDataItem = BaseDataItem>({
   );
 
   // Wrap in scrollable container if virtualized
-  if (virtualized) {
-    return (
-      <div
-        ref={tableContainerRef}
-        onScroll={handleScroll}
-        style={{ height: virtualHeight, overflow: 'auto' }}
-        className="rounded-lg"
-      >
-        {tableContent}
-      </div>
-    );
-  }
+  const finalContent = virtualized ? (
+    <div
+      ref={tableContainerRef}
+      onScroll={handleScroll}
+      style={{ height: virtualHeight, overflow: 'auto' }}
+      className="rounded-lg"
+    >
+      {tableContent}
+    </div>
+  ) : tableContent;
 
-  return tableContent;
+  // Render with context menu
+  return (
+    <>
+      {finalContent}
+      {contextMenuState.isOpen && contextMenuState.item && (
+        <Menu
+          items={convertActionsToMenuItems(contextMenuState.item)}
+          position={contextMenuState.position}
+          onClose={() => setContextMenuState({ isOpen: false, position: { x: 0, y: 0 }, item: null })}
+        />
+      )}
+    </>
+  );
 }

package/src/components/Modal.stories.tsx

@@ -284,3 +284,67 @@ export const NoCloseButton: Story = {
     );
   },
 };
+
+export const TextSelectionTest: Story = {
+  render: () => {
+    const [isOpen, setIsOpen] = useState(false);
+    return (
+      <>
+        <Button onClick={() => setIsOpen(true)}>Test Text Selection</Button>
+        <Modal isOpen={isOpen} onClose={() => setIsOpen(false)} title="Text Selection Test">
+          <div style={{ display: 'flex', flexDirection: 'column', gap: '1rem' }}>
+            <div style={{
+              padding: '1rem',
+              backgroundColor: '#dbeafe',
+              border: '1px solid #3b82f6',
+              borderRadius: '0.375rem'
+            }}>
+              <h4 style={{ fontWeight: 600, marginBottom: '0.5rem', fontSize: '0.875rem', color: '#1e40af' }}>
+                ✅ Bug Fix Test: Text Selection
+              </h4>
+              <p style={{ fontSize: '0.875rem' }}>
+                Try selecting text in the input fields below by clicking and dragging <strong>outside</strong> the modal boundaries.
+                The modal should <strong>NOT</strong> close when you release the mouse button outside.
+              </p>
+            </div>
+            <Input
+              label="Full Name"
+              placeholder="Try selecting this text and dragging outside the modal"
+              defaultValue="John Smith - Drag to select and move mouse outside modal bounds"
+            />
+            <Input
+              label="Email Address"
+              type="email"
+              placeholder="user@example.com"
+              defaultValue="test.user@example.com - Select text here too"
+            />
+            <Input
+              label="Company"
+              placeholder="Company name"
+              defaultValue="This is a long company name that you can select by dragging"
+            />
+            <div style={{
+              padding: '0.75rem',
+              backgroundColor: '#fef3c7',
+              border: '1px solid #f59e0b',
+              borderRadius: '0.375rem',
+              fontSize: '0.875rem'
+            }}>
+              <strong>Test Instructions:</strong>
+              <ol style={{ marginLeft: '1.5rem', marginTop: '0.5rem' }}>
+                <li>Click and hold inside any input field</li>
+                <li>While holding, drag your mouse outside the modal</li>
+                <li>Release the mouse button while outside</li>
+                <li>Modal should remain open! ✅</li>
+              </ol>
+            </div>
+          </div>
+          <ModalFooter>
+            <Button variant="ghost" onClick={() => setIsOpen(false)}>Cancel</Button>
+            <Button variant="primary" onClick={() => setIsOpen(false)}>Save</Button>
+          </ModalFooter>
+        </Modal>
+      </>
+    );
+  },
+};

package/src/components/Modal.tsx

@@ -30,6 +30,7 @@ export default function Modal({
   animation = 'scale',
 }: ModalProps) {
   const modalRef = useRef<HTMLDivElement>(null);
+  const mouseDownOnBackdrop = useRef(false);
   const titleId = useId();
 
   // Handle escape key
@@ -51,11 +52,22 @@ export default function Modal({
     };
   }, [isOpen, onClose]);
 
-  // Handle click outside
-  const handleBackdropClick = (e: React.MouseEvent<HTMLDivElement>) => {
+  // Track if mousedown originated on the backdrop
+  const handleBackdropMouseDown = (e: React.MouseEvent<HTMLDivElement>) => {
     if (e.target === e.currentTarget) {
+      mouseDownOnBackdrop.current = true;
+    } else {
+      mouseDownOnBackdrop.current = false;
+    }
+  };
+
+  // Handle click outside - only close if both mousedown and click happened on backdrop
+  const handleBackdropClick = (e: React.MouseEvent<HTMLDivElement>) => {
+    if (e.target === e.currentTarget && mouseDownOnBackdrop.current) {
       onClose();
     }
+    // Reset the flag after handling click
+    mouseDownOnBackdrop.current = false;
   };
 
   const getAnimationClass = () => {
@@ -80,6 +92,7 @@ export default function Modal({
   return (
     <div
       className="fixed inset-0 z-50 flex items-center justify-center p-4 bg-ink-900 bg-opacity-50 backdrop-blur-sm animate-fade-in"
+      onMouseDown={handleBackdropMouseDown}
       onClick={handleBackdropClick}
     >
       <div

package/src/components/Page.stories.tsx

@@ -278,3 +278,79 @@ export const SettingsPage: Story = {
     </Page>
   ),
 };
+
+export const ResponsiveLayout: Story = {
+  render: () => (
+    <Page>
+      <Card style={{ marginBottom: '1.5rem', backgroundColor: '#dbeafe', border: '1px solid #3b82f6' }}>
+        <CardContent>
+          <h3 style={{ fontWeight: 600, marginBottom: '0.75rem', fontSize: '0.875rem', color: '#1e40af' }}>
+            📐 Responsive Layout (Default)
+          </h3>
+          <p style={{ fontSize: '0.875rem', marginBottom: '0.5rem' }}>
+            Try resizing your browser window! The page keeps <strong>left and top margins/padding fixed</strong>,
+            but <strong>right and bottom resize responsively</strong>:
+          </p>
+          <ul style={{ marginLeft: '1.5rem', fontSize: '0.875rem' }}>
+            <li>• Small screens: Minimal right/bottom padding for more content space</li>
+            <li>• Medium screens: Increased right/bottom padding</li>
+            <li>• Large screens (1024px+): Maximum spacing with centered layout</li>
+          </ul>
+        </CardContent>
+      </Card>
+      <Card>
+        <CardHeader>
+          <CardTitle>Content Adapts to Screen Size</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p style={{ marginBottom: '1rem' }}>
+            This is the default responsive behavior. The notebook aesthetic is maintained
+            across all screen sizes while optimizing for available space.
+          </p>
+          <p>
+            The left binding edge and top margin stay consistent (maintaining the notebook look),
+            while right and bottom spacing adjusts for comfort on different devices.
+          </p>
+        </CardContent>
+      </Card>
+    </Page>
+  ),
+};
+
+export const FixedLayout: Story = {
+  render: () => (
+    <Page fixed={true}>
+      <Card style={{ marginBottom: '1.5rem', backgroundColor: '#fef3c7', border: '1px solid #f59e0b' }}>
+        <CardContent>
+          <h3 style={{ fontWeight: 600, marginBottom: '0.75rem', fontSize: '0.875rem', color: '#92400e' }}>
+            📌 Fixed Layout (fixed=true)
+          </h3>
+          <p style={{ fontSize: '0.875rem', marginBottom: '0.5rem' }}>
+            This page uses <code style={{ backgroundColor: '#fff', padding: '0.125rem 0.375rem', borderRadius: '0.25rem' }}>fixed=true</code>.
+            All margins and padding stay <strong>constant regardless of screen size</strong>:
+          </p>
+          <ul style={{ marginLeft: '1.5rem', fontSize: '0.875rem' }}>
+            <li>• Left, right, top, and bottom spacing never changes</li>
+            <li>• Consistent appearance on all devices</li>
+            <li>• May use more horizontal space on large screens</li>
+          </ul>
+        </CardContent>
+      </Card>
+      <Card>
+        <CardHeader>
+          <CardTitle>Consistent Spacing Everywhere</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p style={{ marginBottom: '1rem' }}>
+            Use the <code style={{ backgroundColor: '#f5f5f5', padding: '0.25rem 0.5rem', borderRadius: '0.25rem' }}>fixed</code> prop
+            when you need absolute consistency across all screen sizes, or when the responsive
+            behavior doesn't match your design requirements.
+          </p>
+          <p>
+            Try resizing your browser - the spacing around this page content remains identical.
+          </p>
+        </CardContent>
+      </Card>
+    </Page>
+  ),
+};

package/src/components/Page.tsx

@@ -12,6 +12,8 @@ export interface PageProps {
   className?: string;
   /** Padding size around the content (default: 'normal') */
   padding?: 'none' | 'sm' | 'normal' | 'lg';
+  /** Fix all margins/padding instead of responsive (default: false) */
+  fixed?: boolean;
 }
 
 /**
@@ -47,14 +49,44 @@ export interface PageProps {
  */
 export const Page: React.FC<PageProps> = ({
   children,
-  maxWidth: _maxWidth = '7xl',
+  maxWidth = '7xl',
   className = '',
-  padding: _padding = 'normal'
+  padding = 'normal',
+  fixed = false
 }) => {
+  // Max width classes
+  const maxWidthClasses = {
+    '4xl': 'max-w-4xl',
+    '5xl': 'max-w-5xl',
+    '6xl': 'max-w-6xl',
+    '7xl': 'max-w-7xl',
+    'full': 'max-w-full',
+  };
+
+  // Padding classes - responsive (fixed left/top, responsive right/bottom) vs all fixed
+  const paddingClasses = {
+    none: fixed ? 'p-0' : 'pt-0 pl-0 pr-0 pb-0',
+    sm: fixed ? 'p-4' : 'pt-4 pl-4 pr-4 pb-4 sm:pr-6 md:pr-8 sm:pb-6 md:pb-8',
+    normal: fixed ? 'pt-12 pl-20 pr-16 pb-12' : 'pt-12 pl-20 pr-4 pb-4 sm:pr-8 md:pr-12 lg:pr-16 sm:pb-8 md:pb-12 lg:pb-16',
+    lg: fixed ? 'pt-16 pl-24 pr-20 pb-16' : 'pt-16 pl-24 pr-6 pb-6 sm:pr-12 md:pr-16 lg:pr-20 sm:pb-12 md:pb-16 lg:pb-20',
+  };
+
+  // Margin classes - responsive (fixed left/top, responsive right/bottom) vs all fixed
+  const marginClasses = fixed
+    ? 'mt-4 ml-4 mr-4 mb-4'
+    : 'mt-4 ml-4 mr-4 mb-4 sm:mr-6 md:mr-8 lg:mr-auto sm:mb-6 md:mb-8';
 
   return (
     <div className="min-h-screen bg-paper-100">
-      <div className={`notebook-page notebook-margin notebook-ruled ${className}`}>
+      <div className={`
+        bg-white bg-subtle-grain rounded-sm shadow-lg border-l-4 border-paper-300
+        min-h-[calc(100vh-2rem)] relative
+        notebook-margin notebook-ruled
+        ${maxWidthClasses[maxWidth]}
+        ${paddingClasses[padding]}
+        ${marginClasses}
+        ${className}
+      `.trim().replace(/\s+/g, ' ')}>
         {children}
       </div>
     </div>

package/src/components/PageLayout.stories.tsx

@@ -586,3 +586,78 @@ export const WithSidebarAndGutter: Story = {
     );
   },
 };
+
+export const ResponsiveLayout: Story = {
+  render: () => (
+    <PageLayout
+      title="Responsive PageLayout"
+      description="Default responsive behavior - resize your browser to see the right and bottom padding adapt"
+    >
+      <Card style={{ marginBottom: '1.5rem', backgroundColor: '#dbeafe', border: '1px solid #3b82f6' }}>
+        <CardContent>
+          <h3 style={{ fontWeight: 600, marginBottom: '0.75rem', fontSize: '0.875rem', color: '#1e40af' }}>
+            📐 Responsive Layout (Default)
+          </h3>
+          <p style={{ fontSize: '0.875rem', marginBottom: '0.5rem' }}>
+            Try resizing your browser window! PageLayout keeps <strong>left and top padding fixed</strong>,
+            but <strong>right and bottom resize responsively</strong>:
+          </p>
+          <ul style={{ marginLeft: '1.5rem', fontSize: '0.875rem' }}>
+            <li>• Small screens: Minimal right/bottom padding (pr-2 pb-8)</li>
+            <li>• Medium screens (640px+): Increased padding (pr-4 pb-12)</li>
+            <li>• Large screens (768px+): More padding (pr-6 pb-16)</li>
+            <li>• XL screens (1024px+): Maximum padding (pb-20)</li>
+          </ul>
+        </CardContent>
+      </Card>
+      <Card>
+        <CardHeader>
+          <CardTitle>Content Adapts to Screen Size</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p>
+            This is perfect for applications where you want the notebook aesthetic to be
+            maintained while optimizing for different device sizes.
+          </p>
+        </CardContent>
+      </Card>
+    </PageLayout>
+  ),
+};
+
+export const FixedLayout: Story = {
+  render: () => (
+    <PageLayout
+      title="Fixed PageLayout"
+      description="All padding remains constant regardless of screen size"
+      fixed={true}
+    >
+      <Card style={{ marginBottom: '1.5rem', backgroundColor: '#fef3c7', border: '1px solid #f59e0b' }}>
+        <CardContent>
+          <h3 style={{ fontWeight: 600, marginBottom: '0.75rem', fontSize: '0.875rem', color: '#92400e' }}>
+            📌 Fixed Layout (fixed=true)
+          </h3>
+          <p style={{ fontSize: '0.875rem', marginBottom: '0.5rem' }}>
+            This page uses <code style={{ backgroundColor: '#fff', padding: '0.125rem 0.375rem', borderRadius: '0.25rem' }}>fixed=true</code>.
+            All padding stays <strong>constant regardless of screen size</strong>:
+          </p>
+          <ul style={{ marginLeft: '1.5rem', fontSize: '0.875rem' }}>
+            <li>• Same padding on mobile and desktop</li>
+            <li>• Predictable layout at all viewport sizes</li>
+            <li>• Use when you need absolute consistency</li>
+          </ul>
+        </CardContent>
+      </Card>
+      <Card>
+        <CardHeader>
+          <CardTitle>Consistent Everywhere</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p>
+            Try resizing your browser - the spacing remains identical at all screen sizes.
+          </p>
+        </CardContent>
+      </Card>
+    </PageLayout>
+  ),
+};