@nlabs/gothamui 1.8.0

package/lib/components/Checkbox/Checkbox.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { memo, useMemo, useState } from 'react';
+import { getCheckedClasses } from '../../utils/colorUtils.js';
+import { useGothamFormField } from '../Form/FormContext.js';
+const CheckboxComponent = ({ color = 'primary', label, defaultValue = false, description, error, containerClass = '', labelClass = '', name, optionClass = '', id, ...props })=>{
+    const form = useGothamFormField(name);
+    const [localChecked, setLocalChecked] = useState(defaultValue);
+    const optionClasses = useMemo(()=>cn(optionClass, getCheckedClasses(color)), [
+        color,
+        optionClass
+    ]);
+    const checkboxId = id || name || label.toLowerCase().replace(/\s+/g, '-');
+    const descriptionId = description ? `${checkboxId}-description` : undefined;
+    const currentValue = form?.value;
+    const uncontrolledChecked = typeof currentValue === 'boolean' ? currentValue : localChecked;
+    const checked = typeof props.checked === 'boolean' ? props.checked : uncontrolledChecked;
+    const handleChange = (event)=>{
+        if (!form) {
+            setLocalChecked(event.target.checked);
+        }
+        form?.setValue(name, event.target.checked);
+        form?.clearError(name);
+        props.onChange?.(event);
+    };
+    const baseCheckboxClasses = `
+    col-start-1 row-start-1 appearance-none rounded-sm border border-gray-300 bg-white
+    checked:border-indigo-600 checked:bg-indigo-600 indeterminate:border-indigo-600
+    indeterminate:bg-indigo-600 focus-visible:outline-2 focus-visible:outline-offset-2
+    focus-visible:outline-indigo-600 disabled:border-gray-300 disabled:bg-gray-100
+    disabled:checked:bg-gray-100 forced-colors:appearance-auto
+    ${error ? 'border-red-300' : ''}
+  `.trim().replace(/\s+/g, ' ');
+    return /*#__PURE__*/ _jsx("fieldset", {
+        "aria-label": label,
+        children: /*#__PURE__*/ _jsxs("div", {
+            className: `flex gap-3 ${containerClass}`,
+            children: [
+                /*#__PURE__*/ _jsx("div", {
+                    className: "flex h-6 shrink-0 items-center",
+                    children: /*#__PURE__*/ _jsxs("div", {
+                        className: "group grid size-4 grid-cols-1",
+                        children: [
+                            /*#__PURE__*/ _jsx("input", {
+                                ...props,
+                                "aria-describedby": descriptionId,
+                                checked: checked,
+                                className: `${baseCheckboxClasses} ${optionClasses}`,
+                                defaultChecked: checked === undefined ? Boolean(form?.defaultValue ?? defaultValue) : undefined,
+                                id: checkboxId,
+                                name: name,
+                                onChange: handleChange,
+                                type: "checkbox",
+                                value: "true"
+                            }),
+                            /*#__PURE__*/ _jsxs("svg", {
+                                className: "pointer-events-none col-start-1 row-start-1 size-3.5 self-center justify-self-center stroke-white group-has-disabled:stroke-gray-950/25",
+                                fill: "none",
+                                viewBox: "0 0 14 14",
+                                children: [
+                                    /*#__PURE__*/ _jsx("path", {
+                                        className: "opacity-0 group-has-checked:opacity-100",
+                                        d: "M3 8L6 11L11 3.5",
+                                        strokeLinecap: "round",
+                                        strokeLinejoin: "round",
+                                        strokeWidth: 2
+                                    }),
+                                    /*#__PURE__*/ _jsx("path", {
+                                        className: "opacity-0 group-has-indeterminate:opacity-100",
+                                        d: "M3 7H11",
+                                        strokeLinecap: "round",
+                                        strokeLinejoin: "round",
+                                        strokeWidth: 2
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                }),
+                /*#__PURE__*/ _jsxs("div", {
+                    className: "text-sm/6",
+                    children: [
+                        /*#__PURE__*/ _jsx("label", {
+                            className: `font-medium text-gray-900 ${labelClass}`,
+                            htmlFor: checkboxId,
+                            children: label
+                        }),
+                        description && /*#__PURE__*/ _jsx("p", {
+                            className: "text-gray-500",
+                            id: descriptionId,
+                            children: description
+                        }),
+                        error && /*#__PURE__*/ _jsx("p", {
+                            className: "text-red-600 mt-1",
+                            children: error
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+export const Checkbox = /*#__PURE__*/ memo(CheckboxComponent);
+Checkbox.displayName = 'Checkbox';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Checkbox/Checkbox.tsx"],"sourcesContent":["import {cn} from '@nlabs/utils';\nimport {memo, useMemo, useState} from 'react';\n\nimport {getCheckedClasses} from '../../utils/colorUtils.js';\nimport {useGothamFormField} from '../Form/FormContext.js';\n\nimport type {ChangeEvent, InputHTMLAttributes} from 'react';\n\nexport interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'className' | 'defaultValue'> {\n  color?: 'primary' | 'secondary' | 'error' | 'success' | 'warning';\n  containerClass?: string;\n  defaultValue?: boolean;\n  description?: string;\n  error?: string;\n  label: string;\n  labelClass?: string;\n  name: string;\n  optionClass?: string;\n}\n\nconst CheckboxComponent = ({\n  color = 'primary',\n  label,\n  defaultValue = false,\n  description,\n  error,\n  containerClass = '',\n  labelClass = '',\n  name,\n  optionClass = '',\n  id,\n  ...props\n}: CheckboxProps) => {\n  const form = useGothamFormField(name);\n  const [localChecked, setLocalChecked] = useState(defaultValue);\n  const optionClasses = useMemo(\n    () => cn(optionClass, getCheckedClasses(color)),\n    [color, optionClass]\n  );\n  const checkboxId = id || name || label.toLowerCase().replace(/\\s+/g, '-');\n  const descriptionId = description ? `${checkboxId}-description` : undefined;\n  const currentValue = form?.value;\n  const uncontrolledChecked = typeof currentValue === 'boolean' ? currentValue : localChecked;\n  const checked = typeof props.checked === 'boolean' ? props.checked : uncontrolledChecked;\n  const handleChange = (event: ChangeEvent<HTMLInputElement>) => {\n    if(!form) {\n      setLocalChecked(event.target.checked);\n    }\n    form?.setValue(name, event.target.checked);\n    form?.clearError(name);\n    props.onChange?.(event);\n  };\n  const baseCheckboxClasses = `\n    col-start-1 row-start-1 appearance-none rounded-sm border border-gray-300 bg-white\n    checked:border-indigo-600 checked:bg-indigo-600 indeterminate:border-indigo-600\n    indeterminate:bg-indigo-600 focus-visible:outline-2 focus-visible:outline-offset-2\n    focus-visible:outline-indigo-600 disabled:border-gray-300 disabled:bg-gray-100\n    disabled:checked:bg-gray-100 forced-colors:appearance-auto\n    ${error ? 'border-red-300' : ''}\n  `.trim().replace(/\\s+/g, ' ');\n  return (\n    <fieldset aria-label={label}>\n      <div className={`flex gap-3 ${containerClass}`}>\n        <div className=\"flex h-6 shrink-0 items-center\">\n          <div className=\"group grid size-4 grid-cols-1\">\n            <input\n              {...props}\n              aria-describedby={descriptionId}\n              checked={checked}\n              className={`${baseCheckboxClasses} ${optionClasses}`}\n              defaultChecked={checked === undefined ? Boolean(form?.defaultValue ?? defaultValue) : undefined}\n              id={checkboxId}\n              name={name}\n              onChange={handleChange}\n              type=\"checkbox\"\n              value=\"true\"\n            />\n            <svg\n              className=\"pointer-events-none col-start-1 row-start-1 size-3.5 self-center justify-self-center stroke-white group-has-disabled:stroke-gray-950/25\"\n              fill=\"none\"\n              viewBox=\"0 0 14 14\"\n            >\n              <path\n                className=\"opacity-0 group-has-checked:opacity-100\"\n                d=\"M3 8L6 11L11 3.5\"\n                strokeLinecap=\"round\"\n                strokeLinejoin=\"round\"\n                strokeWidth={2}\n              />\n              <path\n                className=\"opacity-0 group-has-indeterminate:opacity-100\"\n                d=\"M3 7H11\"\n                strokeLinecap=\"round\"\n                strokeLinejoin=\"round\"\n                strokeWidth={2}\n              />\n            </svg>\n          </div>\n        </div>\n\n        <div className=\"text-sm/6\">\n          <label\n            className={`font-medium text-gray-900 ${labelClass}`}\n            htmlFor={checkboxId}\n          >\n            {label}\n          </label>\n          {description && (\n            <p className=\"text-gray-500\" id={descriptionId}>\n              {description}\n            </p>\n          )}\n          {error && (\n            <p className=\"text-red-600 mt-1\">{error}</p>\n          )}\n        </div>\n      </div>\n    </fieldset>\n  );\n};\n\nexport const Checkbox = memo(CheckboxComponent);\nCheckbox.displayName = 'Checkbox';\n"],"names":["cn","memo","useMemo","useState","getCheckedClasses","useGothamFormField","CheckboxComponent","color","label","defaultValue","description","error","containerClass","labelClass","name","optionClass","id","props","form","localChecked","setLocalChecked","optionClasses","checkboxId","toLowerCase","replace","descriptionId","undefined","currentValue","value","uncontrolledChecked","checked","handleChange","event","target","setValue","clearError","onChange","baseCheckboxClasses","trim","fieldset","aria-label","div","className","input","aria-describedby","defaultChecked","Boolean","type","svg","fill","viewBox","path","d","strokeLinecap","strokeLinejoin","strokeWidth","htmlFor","p","Checkbox","displayName"],"mappings":";AAAA,SAAQA,EAAE,QAAO,eAAe;AAChC,SAAQC,IAAI,EAAEC,OAAO,EAAEC,QAAQ,QAAO,QAAQ;AAE9C,SAAQC,iBAAiB,QAAO,4BAA4B;AAC5D,SAAQC,kBAAkB,QAAO,yBAAyB;AAgB1D,MAAMC,oBAAoB,CAAC,EACzBC,QAAQ,SAAS,EACjBC,KAAK,EACLC,eAAe,KAAK,EACpBC,WAAW,EACXC,KAAK,EACLC,iBAAiB,EAAE,EACnBC,aAAa,EAAE,EACfC,IAAI,EACJC,cAAc,EAAE,EAChBC,EAAE,EACF,GAAGC,OACW;IACd,MAAMC,OAAOb,mBAAmBS;IAChC,MAAM,CAACK,cAAcC,gBAAgB,GAAGjB,SAASM;IACjD,MAAMY,gBAAgBnB,QACpB,IAAMF,GAAGe,aAAaX,kBAAkBG,SACxC;QAACA;QAAOQ;KAAY;IAEtB,MAAMO,aAAaN,MAAMF,QAAQN,MAAMe,WAAW,GAAGC,OAAO,CAAC,QAAQ;IACrE,MAAMC,gBAAgBf,cAAc,GAAGY,WAAW,YAAY,CAAC,GAAGI;IAClE,MAAMC,eAAeT,MAAMU;IAC3B,MAAMC,sBAAsB,OAAOF,iBAAiB,YAAYA,eAAeR;IAC/E,MAAMW,UAAU,OAAOb,MAAMa,OAAO,KAAK,YAAYb,MAAMa,OAAO,GAAGD;IACrE,MAAME,eAAe,CAACC;QACpB,IAAG,CAACd,MAAM;YACRE,gBAAgBY,MAAMC,MAAM,CAACH,OAAO;QACtC;QACAZ,MAAMgB,SAASpB,MAAMkB,MAAMC,MAAM,CAACH,OAAO;QACzCZ,MAAMiB,WAAWrB;QACjBG,MAAMmB,QAAQ,GAAGJ;IACnB;IACA,MAAMK,sBAAsB,CAAC;;;;;;IAM3B,EAAE1B,QAAQ,mBAAmB,GAAG;EAClC,CAAC,CAAC2B,IAAI,GAAGd,OAAO,CAAC,QAAQ;IACzB,qBACE,KAACe;QAASC,cAAYhC;kBACpB,cAAA,MAACiC;YAAIC,WAAW,CAAC,WAAW,EAAE9B,gBAAgB;;8BAC5C,KAAC6B;oBAAIC,WAAU;8BACb,cAAA,MAACD;wBAAIC,WAAU;;0CACb,KAACC;gCACE,GAAG1B,KAAK;gCACT2B,oBAAkBnB;gCAClBK,SAASA;gCACTY,WAAW,GAAGL,oBAAoB,CAAC,EAAEhB,eAAe;gCACpDwB,gBAAgBf,YAAYJ,YAAYoB,QAAQ5B,MAAMT,gBAAgBA,gBAAgBiB;gCACtFV,IAAIM;gCACJR,MAAMA;gCACNsB,UAAUL;gCACVgB,MAAK;gCACLnB,OAAM;;0CAER,MAACoB;gCACCN,WAAU;gCACVO,MAAK;gCACLC,SAAQ;;kDAER,KAACC;wCACCT,WAAU;wCACVU,GAAE;wCACFC,eAAc;wCACdC,gBAAe;wCACfC,aAAa;;kDAEf,KAACJ;wCACCT,WAAU;wCACVU,GAAE;wCACFC,eAAc;wCACdC,gBAAe;wCACfC,aAAa;;;;;;;8BAMrB,MAACd;oBAAIC,WAAU;;sCACb,KAAClC;4BACCkC,WAAW,CAAC,0BAA0B,EAAE7B,YAAY;4BACpD2C,SAASlC;sCAERd;;wBAEFE,6BACC,KAAC+C;4BAAEf,WAAU;4BAAgB1B,IAAIS;sCAC9Bf;;wBAGJC,uBACC,KAAC8C;4BAAEf,WAAU;sCAAqB/B;;;;;;;AAM9C;AAEA,OAAO,MAAM+C,yBAAWzD,KAAKK,mBAAmB;AAChDoD,SAASC,WAAW,GAAG"}

package/lib/components/Checkbox/Checkbox.stories.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Checkbox } from './Checkbox.js';
+const meta = {
+    argTypes: {
+        color: {
+            control: 'select',
+            options: [
+                'primary',
+                'secondary',
+                'error',
+                'success',
+                'warning'
+            ]
+        },
+        defaultValue: {
+            control: 'boolean'
+        },
+        description: {
+            control: 'text'
+        },
+        error: {
+            control: 'text'
+        },
+        label: {
+            control: 'text'
+        }
+    },
+    component: Checkbox,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Form/Checkbox'
+};
+export default meta;
+export const Default = {
+    args: {
+        color: 'primary',
+        defaultValue: false,
+        description: 'Receive release and security notifications.',
+        label: 'Subscribe to updates',
+        name: 'subscribe'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsx(Checkbox, {
+            ...args
+        })
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/ComponentUtils/renderWithAsChild.d.ts

@@ -0,0 +1,9 @@
+import type { ElementType, ReactNode } from 'react';
+type AsChildProps = {
+    readonly as?: ElementType;
+    readonly asChild?: boolean;
+    readonly children?: ReactNode;
+    readonly className?: string;
+};
+export declare const renderWithAsChild: <Props extends AsChildProps>({ as: Comp, asChild, children, className, ...props }: Props, dataAttributes?: Record<string, string | undefined>) => import("react").JSX.Element | null;
+export {};

package/lib/components/ComponentUtils/renderWithAsChild.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, cloneElement, isValidElement } from 'react';
+export const renderWithAsChild = ({ as: Comp = 'div', asChild = false, children, className, ...props }, dataAttributes = {})=>{
+    if (asChild) {
+        const child = Children.only(children);
+        if (!/*#__PURE__*/ isValidElement(child)) {
+            return null;
+        }
+        const element = child;
+        return /*#__PURE__*/ cloneElement(element, {
+            ...dataAttributes,
+            ...props,
+            className: [
+                element.props.className,
+                className
+            ].filter(Boolean).join(' ')
+        });
+    }
+    return /*#__PURE__*/ _jsx(Comp, {
+        ...dataAttributes,
+        ...props,
+        className: className,
+        children: children
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Container/Container.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes } from 'react';
+export type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
+    readonly bleed?: boolean;
+    readonly size?: ContainerSize;
+}
+export declare const Container: ({ bleed, className, size, ...props }: ContainerProps) => import("react").JSX.Element;

package/lib/components/Container/Container.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+const sizeClasses = {
+    full: 'max-w-none',
+    lg: 'max-w-5xl',
+    md: 'max-w-3xl',
+    sm: 'max-w-2xl',
+    xl: 'max-w-7xl'
+};
+export const Container = ({ bleed = false, className, size = 'xl', ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('mx-auto w-full', sizeClasses[size], !bleed && 'px-4 sm:px-6 lg:px-8', className),
+        "data-slot": "container",
+        ...props
+    });
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy9jb21wb25lbnRzL0NvbnRhaW5lci9Db250YWluZXIudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Y259IGZyb20gJ0BubGFicy91dGlscyc7XG5cbmltcG9ydCB0eXBlIHtIVE1MQXR0cmlidXRlc30gZnJvbSAncmVhY3QnO1xuXG5leHBvcnQgdHlwZSBDb250YWluZXJTaXplID0gJ3NtJyB8ICdtZCcgfCAnbGcnIHwgJ3hsJyB8ICdmdWxsJztcblxuZXhwb3J0IGludGVyZmFjZSBDb250YWluZXJQcm9wcyBleHRlbmRzIEhUTUxBdHRyaWJ1dGVzPEhUTUxEaXZFbGVtZW50PiB7XG4gIHJlYWRvbmx5IGJsZWVkPzogYm9vbGVhbjtcbiAgcmVhZG9ubHkgc2l6ZT86IENvbnRhaW5lclNpemU7XG59XG5cbmNvbnN0IHNpemVDbGFzc2VzOiBSZWNvcmQ8Q29udGFpbmVyU2l6ZSwgc3RyaW5nPiA9IHtcbiAgZnVsbDogJ21heC13LW5vbmUnLFxuICBsZzogJ21heC13LTV4bCcsXG4gIG1kOiAnbWF4LXctM3hsJyxcbiAgc206ICdtYXgtdy0yeGwnLFxuICB4bDogJ21heC13LTd4bCdcbn07XG5cbmV4cG9ydCBjb25zdCBDb250YWluZXIgPSAoe1xuICBibGVlZCA9IGZhbHNlLFxuICBjbGFzc05hbWUsXG4gIHNpemUgPSAneGwnLFxuICAuLi5wcm9wc1xufTogQ29udGFpbmVyUHJvcHMpID0+IChcbiAgPGRpdlxuICAgIGNsYXNzTmFtZT17Y24oXG4gICAgICAnbXgtYXV0byB3LWZ1bGwnLFxuICAgICAgc2l6ZUNsYXNzZXNbc2l6ZV0sXG4gICAgICAhYmxlZWQgJiYgJ3B4LTQgc206cHgtNiBsZzpweC04JyxcbiAgICAgIGNsYXNzTmFtZVxuICAgICl9XG4gICAgZGF0YS1zbG90PVwiY29udGFpbmVyXCJcbiAgICB7Li4ucHJvcHN9XG4gIC8+XG4pO1xuIl0sIm5hbWVzIjpbImNuIiwic2l6ZUNsYXNzZXMiLCJmdWxsIiwibGciLCJtZCIsInNtIiwieGwiLCJDb250YWluZXIiLCJibGVlZCIsImNsYXNzTmFtZSIsInNpemUiLCJwcm9wcyIsImRpdiIsImRhdGEtc2xvdCJdLCJtYXBwaW5ncyI6IjtBQUFBLFNBQVFBLEVBQUUsUUFBTyxlQUFlO0FBV2hDLE1BQU1DLGNBQTZDO0lBQ2pEQyxNQUFNO0lBQ05DLElBQUk7SUFDSkMsSUFBSTtJQUNKQyxJQUFJO0lBQ0pDLElBQUk7QUFDTjtBQUVBLE9BQU8sTUFBTUMsWUFBWSxDQUFDLEVBQ3hCQyxRQUFRLEtBQUssRUFDYkMsU0FBUyxFQUNUQyxPQUFPLElBQUksRUFDWCxHQUFHQyxPQUNZLGlCQUNmLEtBQUNDO1FBQ0NILFdBQVdULEdBQ1Qsa0JBQ0FDLFdBQVcsQ0FBQ1MsS0FBSyxFQUNqQixDQUFDRixTQUFTLHdCQUNWQztRQUVGSSxhQUFVO1FBQ1QsR0FBR0YsS0FBSztPQUVYIn0=

package/lib/components/Container/Container.stories.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Container } from './Container.js';
+const meta = {
+    argTypes: {
+        size: {
+            control: 'select',
+            options: [
+                'sm',
+                'md',
+                'lg',
+                'xl',
+                'full'
+            ]
+        }
+    },
+    component: Container,
+    parameters: {
+        layout: 'fullscreen'
+    },
+    title: 'Application UI/Layout/Container'
+};
+export default meta;
+export const Default = {
+    args: {
+        children: /*#__PURE__*/ _jsx("div", {
+            className: "rounded-md border border-border bg-card p-6 text-card-foreground",
+            children: "Constrained content"
+        }),
+        size: 'xl'
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy9jb21wb25lbnRzL0NvbnRhaW5lci9Db250YWluZXIuc3Rvcmllcy50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcblxuaW1wb3J0IHtpbnRlcmFjdFdpdGhDYW52YXN9IGZyb20gJy4uLy4uL3V0aWxzL3N0b3J5SW50ZXJhY3Rpb25zLmpzJztcbmltcG9ydCB7Q29udGFpbmVyfSBmcm9tICcuL0NvbnRhaW5lci5qcyc7XG5cbmltcG9ydCB0eXBlIHtNZXRhLCBTdG9yeU9ian0gZnJvbSAnQG5sYWJzL2xleC9zdG9yeWJvb2snO1xuXG5jb25zdCBtZXRhOiBNZXRhPHR5cGVvZiBDb250YWluZXI+ID0ge1xuICBhcmdUeXBlczoge1xuICAgIHNpemU6IHtcbiAgICAgIGNvbnRyb2w6ICdzZWxlY3QnLFxuICAgICAgb3B0aW9uczogWydzbScsICdtZCcsICdsZycsICd4bCcsICdmdWxsJ11cbiAgICB9XG4gIH0sXG4gIGNvbXBvbmVudDogQ29udGFpbmVyLFxuICBwYXJhbWV0ZXJzOiB7XG4gICAgbGF5b3V0OiAnZnVsbHNjcmVlbidcbiAgfSxcbiAgdGl0bGU6ICdBcHBsaWNhdGlvbiBVSS9MYXlvdXQvQ29udGFpbmVyJ1xufTtcblxuZXhwb3J0IGRlZmF1bHQgbWV0YTtcblxudHlwZSBTdG9yeSA9IFN0b3J5T2JqPHR5cGVvZiBDb250YWluZXI+O1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdDogU3RvcnkgPSB7XG4gIGFyZ3M6IHtcbiAgICBjaGlsZHJlbjogPGRpdiBjbGFzc05hbWU9XCJyb3VuZGVkLW1kIGJvcmRlciBib3JkZXItYm9yZGVyIGJnLWNhcmQgcC02IHRleHQtY2FyZC1mb3JlZ3JvdW5kXCI+Q29uc3RyYWluZWQgY29udGVudDwvZGl2PixcbiAgICBzaXplOiAneGwnXG4gIH0sXG4gIHBsYXk6IGludGVyYWN0V2l0aENhbnZhc1xufTtcbiJdLCJuYW1lcyI6WyJSZWFjdCIsImludGVyYWN0V2l0aENhbnZhcyIsIkNvbnRhaW5lciIsIm1ldGEiLCJhcmdUeXBlcyIsInNpemUiLCJjb250cm9sIiwib3B0aW9ucyIsImNvbXBvbmVudCIsInBhcmFtZXRlcnMiLCJsYXlvdXQiLCJ0aXRsZSIsIkRlZmF1bHQiLCJhcmdzIiwiY2hpbGRyZW4iLCJkaXYiLCJjbGFzc05hbWUiLCJwbGF5Il0sIm1hcHBpbmdzIjoiO0FBQUEsT0FBT0EsV0FBVyxRQUFRO0FBRTFCLFNBQVFDLGtCQUFrQixRQUFPLG1DQUFtQztBQUNwRSxTQUFRQyxTQUFTLFFBQU8saUJBQWlCO0FBSXpDLE1BQU1DLE9BQStCO0lBQ25DQyxVQUFVO1FBQ1JDLE1BQU07WUFDSkMsU0FBUztZQUNUQyxTQUFTO2dCQUFDO2dCQUFNO2dCQUFNO2dCQUFNO2dCQUFNO2FBQU87UUFDM0M7SUFDRjtJQUNBQyxXQUFXTjtJQUNYTyxZQUFZO1FBQ1ZDLFFBQVE7SUFDVjtJQUNBQyxPQUFPO0FBQ1Q7QUFFQSxlQUFlUixLQUFLO0FBSXBCLE9BQU8sTUFBTVMsVUFBaUI7SUFDNUJDLE1BQU07UUFDSkMsd0JBQVUsS0FBQ0M7WUFBSUMsV0FBVTtzQkFBbUU7O1FBQzVGWCxNQUFNO0lBQ1I7SUFDQVksTUFBTWhCO0FBQ1IsRUFBRSJ9

package/lib/components/DateField/DateField.d.ts

@@ -0,0 +1,22 @@
+import type { InputHTMLAttributes, Ref } from 'react';
+import type { GothamColor } from '../../utils/colorUtils.js';
+export interface DateFieldProps extends InputHTMLAttributes<HTMLInputElement> {
+    readonly className?: string;
+    readonly color?: GothamColor;
+    readonly defaultValue?: number;
+    readonly disabled?: boolean;
+    readonly label?: string;
+    readonly labelClass?: string;
+    readonly labelColor?: GothamColor;
+    readonly name: string;
+    readonly error?: boolean;
+    readonly errorColor?: GothamColor;
+    readonly maxDate?: number;
+    readonly minDate?: number;
+    readonly onChange?: (date: any) => void;
+    readonly ref?: Ref<HTMLInputElement>;
+    readonly value?: number;
+}
+declare const DateFieldComponent: ({ className, color, defaultValue, disabled, error: externalError, label, labelClass, labelColor, maxDate, minDate, name, onChange, ref, type, value, ...props }: DateFieldProps) => import("react").JSX.Element;
+export declare const DateField: import("react").MemoExoticComponent<typeof DateFieldComponent>;
+export {};

package/lib/components/DateField/DateField.js

@@ -0,0 +1,145 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { memo, useEffect, useMemo, useRef, useState } from 'react';
+import { useIsMobile } from '../../hooks/useIsMobile.js';
+import { getOutlineClasses } from '../../utils/colorUtils.js';
+import { assignRef } from '../../utils/refUtils.js';
+import { ErrorMessage } from '../ErrorMessage/ErrorMessage.js';
+import { getFormErrorMessage, useGothamFormField } from '../Form/FormContext.js';
+import { InputField } from '../InputField/InputField.js';
+import { Label } from '../Label/Label.js';
+import { DatePicker } from './DatePicker.js';
+const DateFieldComponent = ({ className = 'w-full rounded-md outline-1 outline-solid focus:outline-3 px-3.5 py-2 text-black dark:text-white placeholder:text-black/50 dark:placeholder:text-white/50 sm:text-sm sm:leading-6', color = 'primary', defaultValue, disabled = false, error: externalError, label = '', labelClass = 'mb-1', labelColor = 'neutral', maxDate, minDate, name, onChange, ref, type = 'text', value, ...props })=>{
+    const isMobile = useIsMobile();
+    const form = useGothamFormField(name);
+    const formError = form?.error;
+    const hasError = !!formError || !!externalError;
+    const [isPickerVisible, setIsPickerVisible] = useState(false);
+    const pickerRef = useRef(null);
+    const inputRef = useRef(null);
+    const ensureDateInRange = (timestamp)=>{
+        if (!timestamp) {
+            return timestamp;
+        }
+        if (minDate && timestamp < minDate) {
+            return minDate;
+        }
+        if (maxDate && timestamp > maxDate) {
+            return maxDate;
+        }
+        return timestamp;
+    };
+    const [localValue, setLocalValue] = useState(()=>ensureDateInRange(value ?? defaultValue ?? Date.now()));
+    const currentValue = Number(form?.value ?? value ?? localValue);
+    const outlineClasses = useMemo(()=>getOutlineClasses(hasError ? 'error' : color, {
+            hasFocus: true,
+            hasHover: true
+        }), [
+        color,
+        hasError
+    ]);
+    const inputClasses = [
+        'bg-white/30 dark:bg-black/30',
+        disabled ? 'text-neutral/30 dark:text-neutral-dark/30 outline-neutral/30 dark:outline-neutral-dark/30' : outlineClasses,
+        className
+    ].filter(Boolean).join(' ');
+    const formatDateForInput = (timestamp)=>new Date(timestamp).toISOString().split('T')[0];
+    const parseInputDate = (dateString)=>new Date(dateString).getTime();
+    const isDateValid = (timestamp)=>{
+        if (minDate && timestamp < minDate) {
+            return false;
+        }
+        if (maxDate && timestamp > maxDate) {
+            return false;
+        }
+        return true;
+    };
+    useEffect(()=>{
+        const handleClickOutside = (event)=>{
+            if (pickerRef.current && !pickerRef.current.contains(event.target) && inputRef.current && !inputRef.current.contains(event.target)) {
+                setIsPickerVisible(false);
+            }
+        };
+        document.addEventListener('mousedown', handleClickOutside);
+        return ()=>{
+            document.removeEventListener('mousedown', handleClickOutside);
+        };
+    }, []);
+    const setDateValue = (timestamp)=>{
+        const nextTimestamp = ensureDateInRange(timestamp);
+        if (!form) {
+            setLocalValue(nextTimestamp);
+        }
+        form?.setValue(name, nextTimestamp);
+        if (isDateValid(nextTimestamp)) {
+            form?.clearError(name);
+        }
+        onChange?.(nextTimestamp);
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "flex flex-col w-full",
+        children: [
+            /*#__PURE__*/ _jsx(Label, {
+                className: labelClass,
+                color: labelColor,
+                hasError: hasError,
+                label: label,
+                name: name
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "relative",
+                children: [
+                    /*#__PURE__*/ _jsx("input", {
+                        name: name,
+                        type: "hidden",
+                        value: currentValue || ''
+                    }),
+                    /*#__PURE__*/ _jsx(InputField, {
+                        ...props,
+                        className: inputClasses,
+                        disabled: disabled,
+                        id: name,
+                        max: maxDate ? formatDateForInput(maxDate) : undefined,
+                        min: minDate ? formatDateForInput(minDate) : undefined,
+                        onChange: (changeEvent)=>{
+                            setDateValue(parseInputDate(changeEvent.target.value));
+                        },
+                        onFocus: ()=>{
+                            if (!isMobile) {
+                                setIsPickerVisible(true);
+                            }
+                        },
+                        ref: (node)=>{
+                            inputRef.current = node;
+                            assignRef(ref, node);
+                        },
+                        type: isMobile ? 'date' : type,
+                        value: formatDateForInput(currentValue)
+                    }),
+                    isPickerVisible && !disabled && !isMobile && /*#__PURE__*/ _jsx("div", {
+                        className: "absolute z-10 mt-1",
+                        ref: pickerRef,
+                        children: /*#__PURE__*/ _jsx(DatePicker, {
+                            initialDate: currentValue,
+                            maxDate: maxDate,
+                            minDate: minDate,
+                            onDateSelect: (timestamp)=>{
+                                setDateValue(timestamp);
+                                setIsPickerVisible(false);
+                            }
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx(ErrorMessage, {
+                        message: getFormErrorMessage(formError)
+                    })
+                ]
+            })
+        ]
+    });
+};
+export const DateField = /*#__PURE__*/ memo(DateFieldComponent);
+DateField.displayName = 'DateField';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/DateField/DateField.tsx"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {memo, useEffect, useMemo, useRef, useState} from 'react';\n\nimport {useIsMobile} from '../../hooks/useIsMobile.js';\nimport {getOutlineClasses} from '../../utils/colorUtils.js';\nimport {assignRef} from '../../utils/refUtils.js';\nimport {ErrorMessage} from '../ErrorMessage/ErrorMessage.js';\nimport {getFormErrorMessage, useGothamFormField} from '../Form/FormContext.js';\nimport {InputField, type InputFieldProps} from '../InputField/InputField.js';\nimport {Label} from '../Label/Label.js';\nimport {DatePicker} from './DatePicker.js';\n\nimport type {InputHTMLAttributes, Ref} from 'react';\nimport type {GothamColor} from '../../utils/colorUtils.js';\n\nexport interface DateFieldProps extends InputHTMLAttributes<HTMLInputElement> {\n  readonly className?: string;\n  readonly color?: GothamColor;\n  readonly defaultValue?: number;\n  readonly disabled?: boolean;\n  readonly label?: string;\n  readonly labelClass?: string;\n  readonly labelColor?: GothamColor;\n  readonly name: string;\n  readonly error?: boolean;\n  readonly errorColor?: GothamColor;\n  readonly maxDate?: number;\n  readonly minDate?: number;\n  readonly onChange?: (date) => void;\n  readonly ref?: Ref<HTMLInputElement>;\n  readonly value?: number;\n}\n\nconst DateFieldComponent = ({\n  className = 'w-full rounded-md outline-1 outline-solid focus:outline-3 px-3.5 py-2 text-black dark:text-white placeholder:text-black/50 dark:placeholder:text-white/50 sm:text-sm sm:leading-6',\n  color = 'primary',\n  defaultValue,\n  disabled = false,\n  error: externalError,\n  label = '',\n  labelClass = 'mb-1',\n  labelColor = 'neutral',\n  maxDate,\n  minDate,\n  name,\n  onChange,\n  ref,\n  type = 'text',\n  value,\n  ...props\n}: DateFieldProps) => {\n  const isMobile = useIsMobile();\n  const form = useGothamFormField(name);\n  const formError = form?.error;\n  const hasError = !!formError || !!externalError;\n  const [isPickerVisible, setIsPickerVisible] = useState(false);\n  const pickerRef = useRef<HTMLDivElement>(null);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const ensureDateInRange = (timestamp: number): number => {\n    if(!timestamp) {\n      return timestamp;\n    }\n\n    if(minDate && timestamp < minDate) {\n      return minDate;\n    }\n\n    if(maxDate && timestamp > maxDate) {\n      return maxDate;\n    }\n\n    return timestamp;\n  };\n\n  const [localValue, setLocalValue] = useState(() => ensureDateInRange(value ?? defaultValue ?? Date.now()));\n  const currentValue = Number(form?.value ?? value ?? localValue);\n  const outlineClasses = useMemo(\n    () => getOutlineClasses(hasError ? 'error' : color, {hasFocus: true, hasHover: true}),\n    [color, hasError]\n  );\n  const inputClasses = [\n    'bg-white/30 dark:bg-black/30',\n    disabled ? 'text-neutral/30 dark:text-neutral-dark/30 outline-neutral/30 dark:outline-neutral-dark/30' : outlineClasses,\n    className\n  ].filter(Boolean).join(' ');\n\n  const formatDateForInput = (timestamp: number): string => new Date(timestamp).toISOString().split('T')[0];\n\n  const parseInputDate = (dateString: string): number => new Date(dateString).getTime();\n\n  const isDateValid = (timestamp: number): boolean => {\n    if(minDate && timestamp < minDate) {\n      return false;\n    }\n    if(maxDate && timestamp > maxDate) {\n      return false;\n    }\n    return true;\n  };\n\n  useEffect(() => {\n    const handleClickOutside = (event: MouseEvent) => {\n      if(\n        pickerRef.current &&\n        !pickerRef.current.contains(event.target as Node) &&\n        inputRef.current &&\n        !inputRef.current.contains(event.target as Node)\n      ) {\n        setIsPickerVisible(false);\n      }\n    };\n\n    document.addEventListener('mousedown', handleClickOutside);\n    return () => {\n      document.removeEventListener('mousedown', handleClickOutside);\n    };\n  }, []);\n\n  const setDateValue = (timestamp: number) => {\n    const nextTimestamp = ensureDateInRange(timestamp);\n    if(!form) {\n      setLocalValue(nextTimestamp);\n    }\n    form?.setValue(name, nextTimestamp);\n\n    if(isDateValid(nextTimestamp)) {\n      form?.clearError(name);\n    }\n\n    onChange?.(nextTimestamp);\n  };\n\n  return (\n    <div className=\"flex flex-col w-full\">\n      <Label\n        className={labelClass}\n        color={labelColor}\n        hasError={hasError}\n        label={label}\n        name={name} />\n      <div className=\"relative\">\n        <input name={name} type=\"hidden\" value={currentValue || ''} />\n        <InputField\n          {...props as Omit<InputFieldProps, 'onChange'>}\n          className={inputClasses}\n          disabled={disabled}\n          id={name}\n          max={maxDate ? formatDateForInput(maxDate) : undefined}\n          min={minDate ? formatDateForInput(minDate) : undefined}\n          onChange={(changeEvent) => {\n            setDateValue(parseInputDate(changeEvent.target.value));\n          }}\n          onFocus={() => {\n            if(!isMobile) {\n              setIsPickerVisible(true);\n            }\n          }}\n          ref={(node) => {\n            inputRef.current = node as HTMLInputElement | null;\n            assignRef(ref, node as HTMLInputElement | null);\n          }}\n          type={isMobile ? 'date' : type}\n          value={formatDateForInput(currentValue)}\n        />\n        {isPickerVisible && !disabled && !isMobile && (\n          <div className=\"absolute z-10 mt-1\" ref={pickerRef}>\n            <DatePicker\n              initialDate={currentValue}\n              maxDate={maxDate}\n              minDate={minDate}\n              onDateSelect={(timestamp) => {\n                setDateValue(timestamp);\n                setIsPickerVisible(false);\n              }}\n            />\n          </div>\n        )}\n        <ErrorMessage message={getFormErrorMessage(formError)} />\n      </div>\n    </div>\n  );\n};\n\nexport const DateField = memo(DateFieldComponent);\nDateField.displayName = 'DateField';\n"],"names":["memo","useEffect","useMemo","useRef","useState","useIsMobile","getOutlineClasses","assignRef","ErrorMessage","getFormErrorMessage","useGothamFormField","InputField","Label","DatePicker","DateFieldComponent","className","color","defaultValue","disabled","error","externalError","label","labelClass","labelColor","maxDate","minDate","name","onChange","ref","type","value","props","isMobile","form","formError","hasError","isPickerVisible","setIsPickerVisible","pickerRef","inputRef","ensureDateInRange","timestamp","localValue","setLocalValue","Date","now","currentValue","Number","outlineClasses","hasFocus","hasHover","inputClasses","filter","Boolean","join","formatDateForInput","toISOString","split","parseInputDate","dateString","getTime","isDateValid","handleClickOutside","event","current","contains","target","document","addEventListener","removeEventListener","setDateValue","nextTimestamp","setValue","clearError","div","input","id","max","undefined","min","changeEvent","onFocus","node","initialDate","onDateSelect","message","DateField","displayName"],"mappings":"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"}

package/lib/components/DateField/DateField.stories.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { gothamColors } from '../../utils/colorUtils.js';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { DateField } from './DateField.js';
+const meta = {
+    argTypes: {
+        color: {
+            control: 'select',
+            defaultValue: 'primary',
+            description: 'The color of the date field',
+            options: gothamColors
+        },
+        disabled: {
+            control: 'boolean',
+            defaultValue: false,
+            description: 'Whether the date field is disabled'
+        },
+        error: {
+            control: 'boolean',
+            defaultValue: false,
+            description: 'Whether the date field has an error'
+        },
+        errorColor: {
+            control: 'select',
+            defaultValue: 'error',
+            description: 'The color of the error state',
+            options: gothamColors
+        },
+        label: {
+            control: 'text',
+            description: 'The label text for the date field'
+        },
+        maxDate: {
+            control: 'date',
+            description: 'The maximum allowed date'
+        },
+        minDate: {
+            control: 'date',
+            description: 'The minimum allowed date'
+        }
+    },
+    component: DateField,
+    decorators: [
+        (Story)=>/*#__PURE__*/ _jsx("div", {
+                className: "p-4 max-w-md",
+                children: /*#__PURE__*/ _jsx(Story, {})
+            })
+    ],
+    parameters: {
+        backgrounds: {
+            default: 'light',
+            values: [
+                {
+                    name: 'light',
+                    value: '#ffffff'
+                },
+                {
+                    name: 'dark',
+                    value: '#1a1a1a'
+                }
+            ]
+        },
+        layout: 'centered'
+    },
+    title: 'Components/Form/DateField'
+};
+export default meta;
+export const Default = {
+    args: {
+        color: 'primary',
+        disabled: false,
+        error: false,
+        label: 'Select Date',
+        name: 'date',
+        required: true
+    },
+    play: interactWithCanvas
+};
+export const WithDefaultValue = {
+    args: {
+        color: 'primary',
+        defaultValue: new Date().getTime(),
+        disabled: false,
+        error: false,
+        label: 'Date with Default Value',
+        name: 'dateWithDefault'
+    },
+    play: interactWithCanvas
+};
+export const WithDateRange = {
+    args: {
+        color: 'primary',
+        disabled: false,
+        error: false,
+        label: 'Date with Range',
+        maxDate: new Date(new Date().setFullYear(new Date().getFullYear() + 1)).getTime(),
+        minDate: new Date(new Date().setFullYear(new Date().getFullYear() - 1)).getTime(),
+        name: 'dateWithRange'
+    },
+    play: interactWithCanvas
+};
+export const WithError = {
+    args: {
+        color: 'primary',
+        disabled: false,
+        error: true,
+        errorColor: 'error',
+        label: 'Date with Error',
+        name: 'dateWithError'
+    },
+    play: interactWithCanvas
+};
+export const Disabled = {
+    args: {
+        color: 'primary',
+        defaultValue: new Date().getTime(),
+        disabled: true,
+        error: false,
+        label: 'Disabled Date Field',
+        name: 'disabledDate'
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/DateField/DatePicker.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+interface DatePickerProps {
+    initialDate?: number;
+    maxDate?: number;
+    minDate?: number;
+    onDateSelect?: (date: number) => void;
+}
+export declare const DatePicker: FC<DatePickerProps>;
+export default DatePicker;