@nlabs/gothamui 1.8.0

package/lib/components/Footer/Footer.stories.js

@@ -0,0 +1,184 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Footer } from './Footer.js';
+const links = [
+    {
+        href: '#docs',
+        label: 'Docs'
+    },
+    {
+        href: '#status',
+        label: 'Status'
+    },
+    {
+        href: '#privacy',
+        label: 'Privacy'
+    }
+];
+const linkGroups = [
+    {
+        title: 'Solutions',
+        links: [
+            {
+                href: '#stack-management',
+                label: 'Stack Management'
+            },
+            {
+                href: '#resources',
+                label: 'Resource Monitor'
+            },
+            {
+                href: '#automation',
+                label: 'Automation'
+            }
+        ]
+    },
+    {
+        title: 'Support',
+        links: [
+            {
+                href: '#docs',
+                label: 'Documentation'
+            },
+            {
+                href: '#api',
+                label: 'API Reference'
+            },
+            {
+                href: '#guides',
+                label: 'Support Guides'
+            }
+        ]
+    },
+    {
+        title: 'Company',
+        links: [
+            {
+                href: '#about',
+                label: 'About'
+            },
+            {
+                href: '#blog',
+                label: 'Blog'
+            },
+            {
+                href: '#careers',
+                label: 'Careers'
+            }
+        ]
+    },
+    {
+        title: 'Legal',
+        links: [
+            {
+                href: '#terms',
+                label: 'Terms of service'
+            },
+            {
+                href: '#privacy',
+                label: 'Privacy policy'
+            },
+            {
+                href: '#license',
+                label: 'License'
+            }
+        ]
+    }
+];
+const socialLinks = [
+    {
+        href: '#github',
+        label: 'GitHub',
+        icon: /*#__PURE__*/ _jsx("svg", {
+            "aria-hidden": "true",
+            className: "size-6",
+            fill: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/ _jsx("path", {
+                clipRule: "evenodd",
+                d: "M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z",
+                fillRule: "evenodd"
+            })
+        })
+    },
+    {
+        href: '#x',
+        label: 'X',
+        icon: /*#__PURE__*/ _jsx("svg", {
+            "aria-hidden": "true",
+            className: "size-6",
+            fill: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /*#__PURE__*/ _jsx("path", {
+                d: "M13.6823 10.6218L20.2391 3H18.6854L12.9921 9.61788L8.44486 3H3.2002L10.0765 13.0074L3.2002 21H4.75404L10.7663 14.0113L15.5685 21H20.8131L13.6819 10.6218H13.6823ZM11.5541 13.0956L10.8574 12.0991L5.31391 4.16971H7.70053L12.1742 10.5689L12.8709 11.5655L18.6861 19.8835H16.2995L11.5541 13.096V13.0956Z"
+            })
+        })
+    }
+];
+const meta = {
+    argTypes: {
+        brand: {
+            control: 'text'
+        },
+        copyright: {
+            control: 'text'
+        },
+        supportEmail: {
+            control: 'text'
+        },
+        supportLabel: {
+            control: 'text'
+        },
+        variant: {
+            control: 'select',
+            options: [
+                'small',
+                'large'
+            ]
+        }
+    },
+    component: Footer,
+    parameters: {
+        layout: 'fullscreen'
+    },
+    title: 'Components/Footer'
+};
+export default meta;
+export const Default = {
+    args: {
+        brand: 'GothamUI',
+        copyright: '© 2026 Nitrogen Labs',
+        links,
+        supportEmail: 'support@example.com',
+        supportLabel: 'Support'
+    },
+    play: interactWithCanvas
+};
+export const Small = {
+    args: {
+        brand: 'GothamUI',
+        copyright: '© 2026 Nitrogen Labs',
+        links,
+        supportEmail: 'support@example.com',
+        supportLabel: 'Support',
+        variant: 'small'
+    },
+    play: interactWithCanvas
+};
+export const Large = {
+    args: {
+        brand: /*#__PURE__*/ _jsx("span", {
+            className: "text-2xl font-bold text-white",
+            children: "GothamUI"
+        }),
+        copyright: '© 2026 Nitrogen Labs. All rights reserved.',
+        description: 'Manage cloud applications, deployments, and resources with a polished operational interface.',
+        linkGroups,
+        socialLinks,
+        variant: 'large'
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Footer/Footer.stories.tsx"],"sourcesContent":["import React from 'react';\nimport {interactWithCanvas} from '../../utils/storyInteractions.js';\nimport {Footer} from './Footer.js';\n\nimport type {Meta, StoryObj} from '@nlabs/lex/storybook';\n\nconst links = [\n  {href: '#docs', label: 'Docs'},\n  {href: '#status', label: 'Status'},\n  {href: '#privacy', label: 'Privacy'}\n];\n\nconst linkGroups = [\n  {\n    title: 'Solutions',\n    links: [\n      {href: '#stack-management', label: 'Stack Management'},\n      {href: '#resources', label: 'Resource Monitor'},\n      {href: '#automation', label: 'Automation'}\n    ]\n  },\n  {\n    title: 'Support',\n    links: [\n      {href: '#docs', label: 'Documentation'},\n      {href: '#api', label: 'API Reference'},\n      {href: '#guides', label: 'Support Guides'}\n    ]\n  },\n  {\n    title: 'Company',\n    links: [\n      {href: '#about', label: 'About'},\n      {href: '#blog', label: 'Blog'},\n      {href: '#careers', label: 'Careers'}\n    ]\n  },\n  {\n    title: 'Legal',\n    links: [\n      {href: '#terms', label: 'Terms of service'},\n      {href: '#privacy', label: 'Privacy policy'},\n      {href: '#license', label: 'License'}\n    ]\n  }\n];\n\nconst socialLinks = [\n  {\n    href: '#github',\n    label: 'GitHub',\n    icon: (\n      <svg aria-hidden=\"true\" className=\"size-6\" fill=\"currentColor\" viewBox=\"0 0 24 24\">\n        <path\n          clipRule=\"evenodd\"\n          d=\"M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z\"\n          fillRule=\"evenodd\"\n        />\n      </svg>\n    )\n  },\n  {\n    href: '#x',\n    label: 'X',\n    icon: (\n      <svg aria-hidden=\"true\" className=\"size-6\" fill=\"currentColor\" viewBox=\"0 0 24 24\">\n        <path d=\"M13.6823 10.6218L20.2391 3H18.6854L12.9921 9.61788L8.44486 3H3.2002L10.0765 13.0074L3.2002 21H4.75404L10.7663 14.0113L15.5685 21H20.8131L13.6819 10.6218H13.6823ZM11.5541 13.0956L10.8574 12.0991L5.31391 4.16971H7.70053L12.1742 10.5689L12.8709 11.5655L18.6861 19.8835H16.2995L11.5541 13.096V13.0956Z\" />\n      </svg>\n    )\n  }\n];\n\nconst meta: Meta<typeof Footer> = {\n  argTypes: {\n    brand: {\n      control: 'text'\n    },\n    copyright: {\n      control: 'text'\n    },\n    supportEmail: {\n      control: 'text'\n    },\n    supportLabel: {\n      control: 'text'\n    },\n    variant: {\n      control: 'select',\n      options: ['small', 'large']\n    }\n  },\n  component: Footer,\n  parameters: {\n    layout: 'fullscreen'\n  },\n  title: 'Components/Footer'\n};\n\nexport default meta;\n\ntype Story = StoryObj<typeof Footer>;\n\nexport const Default: Story = {\n  args: {\n    brand: 'GothamUI',\n    copyright: '© 2026 Nitrogen Labs',\n    links,\n    supportEmail: 'support@example.com',\n    supportLabel: 'Support'\n  },\n  play: interactWithCanvas\n};\n\nexport const Small: Story = {\n  args: {\n    brand: 'GothamUI',\n    copyright: '© 2026 Nitrogen Labs',\n    links,\n    supportEmail: 'support@example.com',\n    supportLabel: 'Support',\n    variant: 'small'\n  },\n  play: interactWithCanvas\n};\n\nexport const Large: Story = {\n  args: {\n    brand: <span className=\"text-2xl font-bold text-white\">GothamUI</span>,\n    copyright: '© 2026 Nitrogen Labs. All rights reserved.',\n    description: 'Manage cloud applications, deployments, and resources with a polished operational interface.',\n    linkGroups,\n    socialLinks,\n    variant: 'large'\n  },\n  play: interactWithCanvas\n};\n"],"names":["React","interactWithCanvas","Footer","links","href","label","linkGroups","title","socialLinks","icon","svg","aria-hidden","className","fill","viewBox","path","clipRule","d","fillRule","meta","argTypes","brand","control","copyright","supportEmail","supportLabel","variant","options","component","parameters","layout","Default","args","play","Small","Large","span","description"],"mappings":";AAAA,OAAOA,WAAW,QAAQ;AAC1B,SAAQC,kBAAkB,QAAO,mCAAmC;AACpE,SAAQC,MAAM,QAAO,cAAc;AAInC,MAAMC,QAAQ;IACZ;QAACC,MAAM;QAASC,OAAO;IAAM;IAC7B;QAACD,MAAM;QAAWC,OAAO;IAAQ;IACjC;QAACD,MAAM;QAAYC,OAAO;IAAS;CACpC;AAED,MAAMC,aAAa;IACjB;QACEC,OAAO;QACPJ,OAAO;YACL;gBAACC,MAAM;gBAAqBC,OAAO;YAAkB;YACrD;gBAACD,MAAM;gBAAcC,OAAO;YAAkB;YAC9C;gBAACD,MAAM;gBAAeC,OAAO;YAAY;SAC1C;IACH;IACA;QACEE,OAAO;QACPJ,OAAO;YACL;gBAACC,MAAM;gBAASC,OAAO;YAAe;YACtC;gBAACD,MAAM;gBAAQC,OAAO;YAAe;YACrC;gBAACD,MAAM;gBAAWC,OAAO;YAAgB;SAC1C;IACH;IACA;QACEE,OAAO;QACPJ,OAAO;YACL;gBAACC,MAAM;gBAAUC,OAAO;YAAO;YAC/B;gBAACD,MAAM;gBAASC,OAAO;YAAM;YAC7B;gBAACD,MAAM;gBAAYC,OAAO;YAAS;SACpC;IACH;IACA;QACEE,OAAO;QACPJ,OAAO;YACL;gBAACC,MAAM;gBAAUC,OAAO;YAAkB;YAC1C;gBAACD,MAAM;gBAAYC,OAAO;YAAgB;YAC1C;gBAACD,MAAM;gBAAYC,OAAO;YAAS;SACpC;IACH;CACD;AAED,MAAMG,cAAc;IAClB;QACEJ,MAAM;QACNC,OAAO;QACPI,oBACE,KAACC;YAAIC,eAAY;YAAOC,WAAU;YAASC,MAAK;YAAeC,SAAQ;sBACrE,cAAA,KAACC;gBACCC,UAAS;gBACTC,GAAE;gBACFC,UAAS;;;IAIjB;IACA;QACEd,MAAM;QACNC,OAAO;QACPI,oBACE,KAACC;YAAIC,eAAY;YAAOC,WAAU;YAASC,MAAK;YAAeC,SAAQ;sBACrE,cAAA,KAACC;gBAAKE,GAAE;;;IAGd;CACD;AAED,MAAME,OAA4B;IAChCC,UAAU;QACRC,OAAO;YACLC,SAAS;QACX;QACAC,WAAW;YACTD,SAAS;QACX;QACAE,cAAc;YACZF,SAAS;QACX;QACAG,cAAc;YACZH,SAAS;QACX;QACAI,SAAS;YACPJ,SAAS;YACTK,SAAS;gBAAC;gBAAS;aAAQ;QAC7B;IACF;IACAC,WAAW1B;IACX2B,YAAY;QACVC,QAAQ;IACV;IACAvB,OAAO;AACT;AAEA,eAAeY,KAAK;AAIpB,OAAO,MAAMY,UAAiB;IAC5BC,MAAM;QACJX,OAAO;QACPE,WAAW;QACXpB;QACAqB,cAAc;QACdC,cAAc;IAChB;IACAQ,MAAMhC;AACR,EAAE;AAEF,OAAO,MAAMiC,QAAe;IAC1BF,MAAM;QACJX,OAAO;QACPE,WAAW;QACXpB;QACAqB,cAAc;QACdC,cAAc;QACdC,SAAS;IACX;IACAO,MAAMhC;AACR,EAAE;AAEF,OAAO,MAAMkC,QAAe;IAC1BH,MAAM;QACJX,qBAAO,KAACe;YAAKxB,WAAU;sBAAgC;;QACvDW,WAAW;QACXc,aAAa;QACb/B;QACAE;QACAkB,SAAS;IACX;IACAO,MAAMhC;AACR,EAAE"}

package/lib/components/Form/Form.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { BaseSyntheticEvent, ReactNode } from 'react';
+import type { FormErrors, FormValues } from './FormContext.js';
+export interface GothamFormMethods {
+    readonly formState: {
+        readonly errors: FormErrors;
+        readonly isSubmitting: boolean;
+    };
+    readonly getValues: () => FormValues;
+    readonly register: (name: string) => {
+        readonly defaultValue: unknown;
+        readonly name: string;
+    };
+    readonly setError: (field: string, error: {
+        type: string;
+        message: string;
+    }) => void;
+    readonly setValue: (name: string, value: unknown) => void;
+}
+export interface FormActionState {
+    readonly errors: FormErrors;
+    readonly values: FormValues;
+}
+export interface FormProps<T> {
+    readonly children: ReactNode | ((methods: GothamFormMethods) => ReactNode);
+    readonly className?: string;
+    readonly defaultValues?: FormValues;
+    readonly disabled?: boolean;
+    readonly errors?: FormErrors;
+    readonly mode?: 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';
+    readonly name?: string;
+    readonly onChange?: (data: unknown) => void;
+    readonly onSubmit: (data: T, event: BaseSyntheticEvent, setError: (field: string, error: {
+        type: string;
+        message: string;
+    }) => void) => void | Promise<void>;
+    readonly schema?: z.ZodSchema<T>;
+    readonly showErrors?: boolean;
+    readonly validate?: (data: unknown) => void;
+    readonly validateOnBlur?: boolean;
+}
+export declare const Form: <T extends Record<string, unknown>>({ children, className, defaultValues, disabled, errors, name, schema, showErrors, onSubmit }: FormProps<T>) => import("react").JSX.Element;

package/lib/components/Form/Form.js

@@ -0,0 +1,198 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { startTransition, useActionState, useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { GothamFormContext, GothamFormFieldContext, createFormFieldStore, getFormErrorMessage } from './FormContext.js';
+const getFormDataValue = (formData, key)=>{
+    const values = formData.getAll(key);
+    if (values.length > 1) {
+        return values;
+    }
+    return values[0] ?? '';
+};
+const getValuesFromFormData = (formData)=>{
+    const values = {};
+    Array.from(new Set(Array.from(formData.keys()))).forEach((key)=>{
+        values[key] = getFormDataValue(formData, key);
+    });
+    return values;
+};
+const getErrorsFromZod = (error)=>Object.fromEntries(error.issues.map((issue)=>[
+            issue.path.join('.'),
+            {
+                message: issue.message,
+                type: issue.code
+            }
+        ]));
+const getErrorMessages = (errorObj)=>Object.values(errorObj).map(getFormErrorMessage).filter(Boolean);
+const emptyValues = {};
+const emptyErrors = {};
+export const Form = ({ children, className, defaultValues = emptyValues, disabled = false, errors = emptyErrors, name = 'default', schema, showErrors = false, onSubmit })=>{
+    const [localErrors, setLocalErrors] = useState({});
+    const [localValues, setLocalValues] = useState(defaultValues);
+    const submitEventRef = useRef(null);
+    const [state, submitAction, isPending] = useActionState(async (_previousState, formData)=>{
+        if (disabled) {
+            return {
+                errors: localErrors,
+                values: localValues
+            };
+        }
+        const formValues = {
+            ...defaultValues,
+            ...getValuesFromFormData(formData),
+            ...localValues
+        };
+        const parsed = schema ? schema.safeParse(formValues) : {
+            data: formValues,
+            success: true
+        };
+        if (!parsed.success) {
+            const nextErrors = getErrorsFromZod(parsed.error);
+            setLocalErrors(nextErrors);
+            return {
+                errors: nextErrors,
+                values: formValues
+            };
+        }
+        const nextErrors = {};
+        const setError = (field, error)=>{
+            nextErrors[field] = error;
+        };
+        await onSubmit(parsed.data, submitEventRef.current, setError);
+        setLocalErrors(nextErrors);
+        return {
+            errors: nextErrors,
+            values: formValues
+        };
+    }, {
+        errors: {},
+        values: defaultValues
+    });
+    const allErrors = useMemo(()=>({
+            ...localErrors,
+            ...errors
+        }), [
+        errors,
+        localErrors
+    ]);
+    const values = useMemo(()=>({
+            ...state.values,
+            ...localValues
+        }), [
+        localValues,
+        state.values
+    ]);
+    const setValue = useCallback((fieldName, value)=>{
+        setLocalValues((currentValues)=>{
+            if (Object.hasOwn(currentValues, fieldName) && Object.is(currentValues[fieldName], value)) {
+                return currentValues;
+            }
+            return {
+                ...currentValues,
+                [fieldName]: value
+            };
+        });
+    }, []);
+    const clearError = useCallback((fieldName)=>{
+        setLocalErrors((currentErrors)=>{
+            if (!Object.hasOwn(currentErrors, fieldName)) {
+                return currentErrors;
+            }
+            const nextErrors = {
+                ...currentErrors
+            };
+            delete nextErrors[fieldName];
+            return nextErrors;
+        });
+    }, []);
+    const methods = useMemo(()=>({
+            formState: {
+                errors: allErrors,
+                isSubmitting: isPending
+            },
+            getValues: ()=>values,
+            register: (fieldName)=>({
+                    defaultValue: values[fieldName] ?? defaultValues[fieldName] ?? '',
+                    name: fieldName
+                }),
+            setError: (fieldName, error)=>{
+                setLocalErrors((currentErrors)=>({
+                        ...currentErrors,
+                        [fieldName]: error
+                    }));
+            },
+            setValue
+        }), [
+        allErrors,
+        defaultValues,
+        isPending,
+        setValue,
+        values
+    ]);
+    const contextValue = useMemo(()=>({
+            clearError,
+            defaultValues,
+            errors: allErrors,
+            isSubmitting: isPending,
+            setValue,
+            values
+        }), [
+        allErrors,
+        clearError,
+        defaultValues,
+        isPending,
+        setValue,
+        values
+    ]);
+    const [fieldStore] = useState(()=>createFormFieldStore(contextValue));
+    // Publish committed React state, never state from an abandoned render.
+    useLayoutEffect(()=>{
+        fieldStore.update(contextValue);
+    }, [
+        contextValue,
+        fieldStore
+    ]);
+    const errorMessages = getErrorMessages(allErrors);
+    const handleFormSubmit = (event)=>{
+        event.preventDefault();
+        event.stopPropagation();
+        if (isPending || disabled) {
+            return;
+        }
+        submitEventRef.current = event;
+        const formData = new FormData(event.currentTarget);
+        startTransition(()=>{
+            submitAction(formData);
+        });
+    };
+    return /*#__PURE__*/ _jsx(GothamFormFieldContext.Provider, {
+        value: fieldStore,
+        children: /*#__PURE__*/ _jsx(GothamFormContext.Provider, {
+            value: contextValue,
+            children: /*#__PURE__*/ _jsxs("form", {
+                className: className,
+                "data-testid": `form-${name}`,
+                noValidate: true,
+                onSubmit: handleFormSubmit,
+                children: [
+                    showErrors && errorMessages.length > 0 && /*#__PURE__*/ _jsx("div", {
+                        "aria-live": "polite",
+                        className: "p-3 mb-4 text-sm text-red-700 bg-red-100 rounded-lg dark:bg-red-200 dark:text-red-800",
+                        role: "alert",
+                        children: /*#__PURE__*/ _jsx("ul", {
+                            className: "list-disc list-inside",
+                            children: errorMessages.map((message, index)=>/*#__PURE__*/ _jsx("li", {
+                                    children: message
+                                }, index))
+                        })
+                    }),
+                    typeof children === 'function' ? children(methods) : children
+                ]
+            })
+        })
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Form/Form.tsx"],"sourcesContent":["/**\n * Copyright (c) 2021-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {startTransition, useActionState, useCallback, useLayoutEffect, useMemo, useRef, useState} from 'react';\nimport {z} from 'zod';\n\nimport {GothamFormContext, GothamFormFieldContext, createFormFieldStore, getFormErrorMessage} from './FormContext.js';\n\nimport type {BaseSyntheticEvent, FormEvent, ReactNode} from 'react';\nimport type {FormErrors, FormValues} from './FormContext.js';\n\nexport interface GothamFormMethods {\n  readonly formState: {\n    readonly errors: FormErrors;\n    readonly isSubmitting: boolean;\n  };\n  readonly getValues: () => FormValues;\n  readonly register: (name: string) => {\n    readonly defaultValue: unknown;\n    readonly name: string;\n  };\n  readonly setError: (field: string, error: {type: string; message: string}) => void;\n  readonly setValue: (name: string, value: unknown) => void;\n}\n\nexport interface FormActionState {\n  readonly errors: FormErrors;\n  readonly values: FormValues;\n}\n\nexport interface FormProps<T> {\n  readonly children: ReactNode | ((methods: GothamFormMethods) => ReactNode);\n  readonly className?: string;\n  readonly defaultValues?: FormValues;\n  readonly disabled?: boolean;\n  readonly errors?: FormErrors;\n  readonly mode?: 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';\n  readonly name?: string;\n  readonly onChange?: (data: unknown) => void;\n  readonly onSubmit: (\n    data: T,\n    event: BaseSyntheticEvent,\n    setError: (field: string, error: {type: string; message: string}) => void\n  ) => void | Promise<void>;\n  readonly schema?: z.ZodSchema<T>;\n  readonly showErrors?: boolean;\n  readonly validate?: (data: unknown) => void;\n  readonly validateOnBlur?: boolean;\n}\n\nconst getFormDataValue = (formData: FormData, key: string): unknown => {\n  const values = formData.getAll(key);\n\n  if(values.length > 1) {\n    return values;\n  }\n\n  return values[0] ?? '';\n};\n\nconst getValuesFromFormData = (formData: FormData): FormValues => {\n  const values: FormValues = {};\n\n  Array.from(new Set(Array.from(formData.keys()))).forEach((key) => {\n    values[key] = getFormDataValue(formData, key);\n  });\n\n  return values;\n};\n\nconst getErrorsFromZod = (error: z.ZodError): FormErrors => Object.fromEntries(\n  error.issues.map((issue) => [\n    issue.path.join('.'),\n    {\n      message: issue.message,\n      type: issue.code\n    }\n  ])\n);\n\nconst getErrorMessages = (errorObj: FormErrors): string[] => Object.values(errorObj)\n  .map(getFormErrorMessage)\n  .filter(Boolean) as string[];\n\nconst emptyValues: FormValues = {};\nconst emptyErrors: FormErrors = {};\n\nexport const Form = <T extends Record<string, unknown>>({\n  children,\n  className,\n  defaultValues = emptyValues,\n  disabled = false,\n  errors = emptyErrors,\n  name = 'default',\n  schema,\n  showErrors = false,\n  onSubmit\n}: FormProps<T>) => {\n  const [localErrors, setLocalErrors] = useState<FormErrors>({});\n  const [localValues, setLocalValues] = useState<FormValues>(defaultValues);\n  const submitEventRef = useRef<BaseSyntheticEvent | null>(null);\n  const [state, submitAction, isPending] = useActionState(\n    async (_previousState: FormActionState, formData: FormData): Promise<FormActionState> => {\n      if(disabled) {\n        return {\n          errors: localErrors,\n          values: localValues\n        };\n      }\n\n      const formValues = {\n        ...defaultValues,\n        ...getValuesFromFormData(formData),\n        ...localValues\n      };\n      const parsed = schema ? schema.safeParse(formValues) : {data: formValues as T, success: true as const};\n\n      if(!parsed.success) {\n        const nextErrors = getErrorsFromZod(parsed.error);\n        setLocalErrors(nextErrors);\n        return {\n          errors: nextErrors,\n          values: formValues\n        };\n      }\n\n      const nextErrors: FormErrors = {};\n      const setError = (field: string, error: {type: string; message: string}) => {\n        nextErrors[field] = error;\n      };\n\n      await onSubmit(parsed.data, submitEventRef.current as BaseSyntheticEvent, setError);\n      setLocalErrors(nextErrors);\n\n      return {\n        errors: nextErrors,\n        values: formValues\n      };\n    },\n    {\n      errors: {},\n      values: defaultValues\n    }\n  );\n  const allErrors = useMemo(() => ({\n    ...localErrors,\n    ...errors\n  }), [errors, localErrors]);\n  const values = useMemo(() => ({\n    ...state.values,\n    ...localValues\n  }), [localValues, state.values]);\n  const setValue = useCallback((fieldName: string, value: unknown) => {\n    setLocalValues((currentValues) => {\n      if(Object.hasOwn(currentValues, fieldName) && Object.is(currentValues[fieldName], value)) {\n        return currentValues;\n      }\n      return {...currentValues, [fieldName]: value};\n    });\n  }, []);\n  const clearError = useCallback((fieldName: string) => {\n    setLocalErrors((currentErrors) => {\n      if(!Object.hasOwn(currentErrors, fieldName)) {\n        return currentErrors;\n      }\n\n      const nextErrors = {...currentErrors};\n      delete nextErrors[fieldName];\n      return nextErrors;\n    });\n  }, []);\n  const methods: GothamFormMethods = useMemo(() => ({\n    formState: {\n      errors: allErrors,\n      isSubmitting: isPending\n    },\n    getValues: () => values,\n    register: (fieldName: string) => ({\n      defaultValue: values[fieldName] ?? defaultValues[fieldName] ?? '',\n      name: fieldName\n    }),\n    setError: (fieldName: string, error: {type: string; message: string}) => {\n      setLocalErrors((currentErrors) => ({\n        ...currentErrors,\n        [fieldName]: error\n      }));\n    },\n    setValue\n  }), [allErrors, defaultValues, isPending, setValue, values]);\n  const contextValue = useMemo(() => ({\n    clearError,\n    defaultValues,\n    errors: allErrors,\n    isSubmitting: isPending,\n    setValue,\n    values\n  }), [allErrors, clearError, defaultValues, isPending, setValue, values]);\n  const [fieldStore] = useState(() => createFormFieldStore(contextValue));\n\n  // Publish committed React state, never state from an abandoned render.\n  useLayoutEffect(() => {\n    fieldStore.update(contextValue);\n  }, [contextValue, fieldStore]);\n  const errorMessages = getErrorMessages(allErrors);\n  const handleFormSubmit = (event: FormEvent<HTMLFormElement>) => {\n    event.preventDefault();\n    event.stopPropagation();\n\n    if(isPending || disabled) {\n      return;\n    }\n\n    submitEventRef.current = event as unknown as BaseSyntheticEvent;\n    const formData = new FormData(event.currentTarget);\n    startTransition(() => {\n      submitAction(formData);\n    });\n  };\n\n  return (\n    <GothamFormFieldContext.Provider value={fieldStore}>\n      <GothamFormContext.Provider value={contextValue}>\n        <form\n          className={className}\n          data-testid={`form-${name}`}\n          noValidate\n          onSubmit={handleFormSubmit}\n        >\n          {showErrors && errorMessages.length > 0 && (\n            <div\n              aria-live=\"polite\"\n              className=\"p-3 mb-4 text-sm text-red-700 bg-red-100 rounded-lg dark:bg-red-200 dark:text-red-800\"\n              role=\"alert\"\n            >\n              <ul className=\"list-disc list-inside\">\n                {errorMessages.map((message, index) => (\n                  <li key={index}>{message}</li>\n                ))}\n              </ul>\n            </div>\n          )}\n          {typeof children === 'function' ? children(methods) : children}\n        </form>\n      </GothamFormContext.Provider>\n    </GothamFormFieldContext.Provider>\n  );\n};\n"],"names":["startTransition","useActionState","useCallback","useLayoutEffect","useMemo","useRef","useState","GothamFormContext","GothamFormFieldContext","createFormFieldStore","getFormErrorMessage","getFormDataValue","formData","key","values","getAll","length","getValuesFromFormData","Array","from","Set","keys","forEach","getErrorsFromZod","error","Object","fromEntries","issues","map","issue","path","join","message","type","code","getErrorMessages","errorObj","filter","Boolean","emptyValues","emptyErrors","Form","children","className","defaultValues","disabled","errors","name","schema","showErrors","onSubmit","localErrors","setLocalErrors","localValues","setLocalValues","submitEventRef","state","submitAction","isPending","_previousState","formValues","parsed","safeParse","data","success","nextErrors","setError","field","current","allErrors","setValue","fieldName","value","currentValues","hasOwn","is","clearError","currentErrors","methods","formState","isSubmitting","getValues","register","defaultValue","contextValue","fieldStore","update","errorMessages","handleFormSubmit","event","preventDefault","stopPropagation","FormData","currentTarget","Provider","form","data-testid","noValidate","div","aria-live","role","ul","index","li"],"mappings":"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"}

package/lib/components/Form/Form.stories.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Button } from '../Button/Button.js';
+import { TextField } from '../TextField/TextField.js';
+import { Form } from './Form.js';
+const meta = {
+    argTypes: {
+        disabled: {
+            control: 'boolean'
+        },
+        mode: {
+            control: 'select',
+            options: [
+                'onSubmit',
+                'onBlur',
+                'onChange',
+                'onTouched',
+                'all'
+            ]
+        },
+        name: {
+            control: 'text'
+        },
+        showErrors: {
+            control: 'boolean'
+        }
+    },
+    component: Form,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Form/Form'
+};
+export default meta;
+export const Default = {
+    args: {
+        defaultValues: {
+            email: ''
+        },
+        disabled: false,
+        mode: 'onBlur',
+        name: 'storybook',
+        showErrors: false
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsxs(Form, {
+            ...args,
+            className: "flex w-80 flex-col gap-3",
+            onSubmit: ()=>undefined,
+            children: [
+                /*#__PURE__*/ _jsx(TextField, {
+                    borderType: "rounded",
+                    name: "email",
+                    placeholder: "Email address"
+                }),
+                /*#__PURE__*/ _jsx(Button, {
+                    label: "Submit",
+                    type: "submit"
+                })
+            ]
+        })
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Form/FormContext.d.ts

@@ -0,0 +1,35 @@
+export type FormErrors = Record<string, {
+    readonly message?: string;
+    readonly type?: string;
+} | string | undefined>;
+export type FormValues = Record<string, unknown>;
+export interface GothamFormContextValue {
+    readonly clearError: (name: string) => void;
+    readonly defaultValues: FormValues;
+    readonly errors: FormErrors;
+    readonly isSubmitting: boolean;
+    readonly setValue: (name: string, value: unknown) => void;
+    readonly values: FormValues;
+}
+export declare const GothamFormContext: import("react").Context<GothamFormContextValue | null>;
+export declare const useGothamFormContext: () => GothamFormContextValue | null;
+export declare const getFormErrorMessage: (error: FormErrors[string]) => string | undefined;
+export interface GothamFormFieldValue {
+    readonly clearError: GothamFormContextValue['clearError'];
+    readonly defaultValue: unknown;
+    readonly error: FormErrors[string];
+    readonly setValue: GothamFormContextValue['setValue'];
+    readonly value: unknown;
+}
+export declare const createFormFieldStore: (initialValue: GothamFormContextValue) => {
+    getSnapshot: () => GothamFormContextValue;
+    subscribe: (listener: () => void) => () => void;
+    update: (value: GothamFormContextValue) => void;
+};
+export declare const GothamFormFieldContext: import("react").Context<{
+    getSnapshot: () => GothamFormContextValue;
+    subscribe: (listener: () => void) => () => void;
+    update: (value: GothamFormContextValue) => void;
+} | null>;
+/** Subscribe only to the named field. Use the full context for cross-field UI. */
+export declare const useGothamFormField: (name: string) => GothamFormFieldValue | null;

package/lib/components/Form/FormContext.js

@@ -0,0 +1,71 @@
+import { createContext, use, useContext, useMemo, useSyncExternalStore } from 'react';
+export const GothamFormContext = createContext(null);
+export const useGothamFormContext = ()=>useContext(GothamFormContext);
+export const getFormErrorMessage = (error)=>{
+    if (typeof error === 'string') {
+        return error;
+    }
+    return error?.message;
+};
+// This subscription adapter exposes committed form state at field granularity.
+// React remains the owner of the form's values and validation state.
+export const createFormFieldStore = (initialValue)=>{
+    let currentValue = initialValue;
+    const listeners = new Set();
+    return {
+        getSnapshot: ()=>currentValue,
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>{
+                listeners.delete(listener);
+            };
+        },
+        update: (value)=>{
+            if (currentValue === value) {
+                return;
+            }
+            currentValue = value;
+            listeners.forEach((listener)=>listener());
+        }
+    };
+};
+export const GothamFormFieldContext = createContext(null);
+const subscribeWithoutForm = ()=>()=>{};
+/** Subscribe only to the named field. Use the full context for cross-field UI. */ export const useGothamFormField = (name)=>{
+    const store = useContext(GothamFormFieldContext);
+    const legacyForm = store ? null : use(GothamFormContext);
+    const getSnapshot = useMemo(()=>{
+        let previous = null;
+        return ()=>{
+            if (!store) {
+                return null;
+            }
+            const form = store.getSnapshot();
+            const next = {
+                clearError: form.clearError,
+                defaultValue: form.defaultValues[name],
+                error: form.errors[name],
+                setValue: form.setValue,
+                value: form.values[name]
+            };
+            if (previous && Object.is(previous.value, next.value) && Object.is(previous.defaultValue, next.defaultValue) && previous.error === next.error && previous.clearError === next.clearError && previous.setValue === next.setValue) {
+                return previous;
+            }
+            previous = next;
+            return next;
+        };
+    }, [
+        name,
+        store
+    ]);
+    const field = useSyncExternalStore(store?.subscribe ?? subscribeWithoutForm, getSnapshot, getSnapshot);
+    return legacyForm ? {
+        clearError: legacyForm.clearError,
+        defaultValue: legacyForm.defaultValues[name],
+        error: legacyForm.errors[name],
+        setValue: legacyForm.setValue,
+        value: legacyForm.values[name]
+    } : field;
+};
+
+//# sourceMappingURL=data:application/json;base64,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