@nlabs/gothamui 1.8.0

package/lib/utils/timer.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ /**
+ * Create a Timer
+ * @param {Number} delay
+ * @param {Function} callback
+ * @constructor
+ */ export class GothamTimer {
+    timerId;
+    start = 0;
+    remaining = 0;
+    delay = 0;
+    callback;
+    constructor(delay, callback){
+        this.callback = callback;
+        this.delay = delay;
+        this.remaining = delay;
+        // Methods
+        this.getTimeRemaining = this.getTimeRemaining.bind(this);
+        this.pause = this.pause.bind(this);
+        this.resume = this.resume.bind(this);
+    }
+    pause() {
+        clearTimeout(this.timerId);
+        this.remaining -= +new Date() - this.start;
+    }
+    resume() {
+        this.start = +new Date();
+        clearTimeout(this.timerId);
+        this.timerId = setTimeout(this.callback, this.remaining);
+    }
+    getTimeRemaining() {
+        return this.remaining;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/useBreakpoint.d.ts

@@ -0,0 +1,6 @@
+export declare const useBreakpoint: () => {
+    at: (size: string) => boolean;
+    down: (size: string) => boolean;
+    up: (size: string) => boolean;
+    value: () => string;
+};

package/lib/utils/useBreakpoint.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { throttle } from '@nlabs/utils';
+import { useEffect, useMemo, useState } from 'react';
+const getCurrentBreakpoint = (setBreakpoint)=>()=>{
+        const breakpoints = {
+            values: {
+                lg: 1200,
+                md: 900,
+                sm: 600,
+                xl: 1536
+            }
+        };
+        const { values: { lg, md, sm, xl } } = breakpoints;
+        const { innerWidth } = window;
+        if (innerWidth < sm) {
+            setBreakpoint(0);
+        } else if (innerWidth < md) {
+            setBreakpoint(1);
+        } else if (innerWidth < lg) {
+            setBreakpoint(2);
+        } else if (innerWidth < xl) {
+            setBreakpoint(3);
+        } else {
+            setBreakpoint(4);
+        }
+    };
+const breakpointValues = [
+    'xs',
+    'sm',
+    'md',
+    'lg',
+    'xl'
+];
+export const useBreakpoint = ()=>{
+    const [breakpoint, setBreakpoint] = useState(0);
+    useEffect(()=>{
+        const onResizeBreakpoint = getCurrentBreakpoint(setBreakpoint);
+        const onResize = throttle(onResizeBreakpoint, 100);
+        // Inital sizing
+        onResizeBreakpoint();
+        window.addEventListener('resize', onResize);
+        return ()=>window.removeEventListener('resize', onResize);
+    }, []);
+    return useMemo(()=>({
+            at: (size)=>size === breakpointValues[breakpoint],
+            down: (size)=>breakpointValues.indexOf(size) >= breakpoint,
+            up: (size)=>breakpointValues.indexOf(size) <= breakpoint,
+            value: ()=>breakpointValues[breakpoint]
+        }), [
+        breakpoint
+    ]);
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/viewPerformance.d.ts

@@ -0,0 +1,34 @@
+import type { AwsRum } from './awsRum.js';
+export type ViewPerformanceOutcome = 'cancelled' | 'failure' | 'success' | 'timeout';
+export type ViewPerformanceStatus = 'failure' | 'pending' | 'success';
+export interface ViewPerformanceMeasurement {
+    readonly durationMs: number;
+    readonly outcome: ViewPerformanceOutcome;
+    readonly route?: string;
+    readonly title?: string;
+    readonly viewId: string;
+}
+export interface StartViewOptions {
+    readonly now?: () => number;
+    readonly onComplete: (measurement: ViewPerformanceMeasurement) => void;
+    readonly route?: string;
+    readonly timeoutMs?: number;
+    readonly title?: string;
+    readonly viewId: string;
+}
+export interface ViewPerformanceHandle {
+    readonly cancel: () => void;
+    readonly fail: () => void;
+    readonly succeed: () => void;
+    readonly timeout: () => void;
+}
+export interface UseViewPerformanceOptions {
+    readonly route?: string;
+    readonly status: ViewPerformanceStatus;
+    readonly timeoutMs?: number;
+    readonly title?: string;
+    readonly viewId: string;
+}
+export declare const startView: ({ now, onComplete, route, timeoutMs, title, viewId }: StartViewOptions) => ViewPerformanceHandle;
+export declare const reportViewPerformance: (awsRum: AwsRum | undefined, measurement: ViewPerformanceMeasurement) => void;
+export declare const useViewPerformance: ({ route, status, timeoutMs, title, viewId }: UseViewPerformanceOptions) => void;

package/lib/utils/viewPerformance.js

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { useContext, useEffect, useRef } from 'react';
+import { GothamContext } from './GothamContext.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const normalizeDuration = (duration)=>Math.max(0, Math.round(duration));
+export const startView = ({ now = ()=>globalThis.performance?.now?.() ?? Date.now(), onComplete, route, timeoutMs = DEFAULT_TIMEOUT_MS, title, viewId })=>{
+    const startedAt = now();
+    let complete = false;
+    let timer;
+    const finish = (outcome)=>{
+        if (complete) {
+            return;
+        }
+        complete = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        onComplete({
+            durationMs: normalizeDuration(now() - startedAt),
+            outcome,
+            ...route ? {
+                route
+            } : {},
+            ...title ? {
+                title
+            } : {},
+            viewId
+        });
+    };
+    if (timeoutMs > 0) {
+        timer = setTimeout(()=>finish('timeout'), timeoutMs);
+    }
+    return {
+        cancel: ()=>finish('cancelled'),
+        fail: ()=>finish('failure'),
+        succeed: ()=>finish('success'),
+        timeout: ()=>finish('timeout')
+    };
+};
+export const reportViewPerformance = (awsRum, measurement)=>{
+    awsRum?.track({
+        name: 'view_performance',
+        ...measurement.route ? {
+            path: measurement.route
+        } : {},
+        properties: {
+            durationMs: measurement.durationMs,
+            outcome: measurement.outcome,
+            ...measurement.title ? {
+                viewTitle: measurement.title
+            } : {},
+            viewId: measurement.viewId
+        },
+        type: 'view_performance'
+    });
+};
+export const useViewPerformance = ({ route, status, timeoutMs, title, viewId })=>{
+    const { awsRum } = useContext(GothamContext);
+    const handleRef = useRef(undefined);
+    const statusRef = useRef(status);
+    statusRef.current = status;
+    useEffect(()=>{
+        const handle = startView({
+            onComplete: (measurement)=>reportViewPerformance(awsRum, measurement),
+            route,
+            timeoutMs,
+            title,
+            viewId
+        });
+        handleRef.current = handle;
+        if (statusRef.current === 'failure') {
+            handle.fail();
+        } else if (statusRef.current === 'success') {
+            handle.succeed();
+        }
+        return ()=>{
+            handle.cancel();
+            if (handleRef.current === handle) {
+                handleRef.current = undefined;
+            }
+        };
+    }, [
+        awsRum,
+        route,
+        timeoutMs,
+        title,
+        viewId
+    ]);
+    useEffect(()=>{
+        if (status === 'failure') {
+            handleRef.current?.fail();
+        } else if (status === 'success') {
+            handleRef.current?.succeed();
+        }
+    }, [
+        status
+    ]);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/utils/viewPerformance.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {useContext, useEffect, useRef} from 'react';\n\nimport {GothamContext} from './GothamContext.js';\n\nimport type {AwsRum} from './awsRum.js';\n\nexport type ViewPerformanceOutcome = 'cancelled' | 'failure' | 'success' | 'timeout';\nexport type ViewPerformanceStatus = 'failure' | 'pending' | 'success';\n\nexport interface ViewPerformanceMeasurement {\n  readonly durationMs: number;\n  readonly outcome: ViewPerformanceOutcome;\n  readonly route?: string;\n  readonly title?: string;\n  readonly viewId: string;\n}\n\nexport interface StartViewOptions {\n  readonly now?: () => number;\n  readonly onComplete: (measurement: ViewPerformanceMeasurement) => void;\n  readonly route?: string;\n  readonly timeoutMs?: number;\n  readonly title?: string;\n  readonly viewId: string;\n}\n\nexport interface ViewPerformanceHandle {\n  readonly cancel: () => void;\n  readonly fail: () => void;\n  readonly succeed: () => void;\n  readonly timeout: () => void;\n}\n\nexport interface UseViewPerformanceOptions {\n  readonly route?: string;\n  readonly status: ViewPerformanceStatus;\n  readonly timeoutMs?: number;\n  readonly title?: string;\n  readonly viewId: string;\n}\n\nconst DEFAULT_TIMEOUT_MS = 30_000;\nconst normalizeDuration = (duration: number): number => Math.max(0, Math.round(duration));\n\nexport const startView = ({\n  now = () => globalThis.performance?.now?.() ?? Date.now(),\n  onComplete,\n  route,\n  timeoutMs = DEFAULT_TIMEOUT_MS,\n  title,\n  viewId\n}: StartViewOptions): ViewPerformanceHandle => {\n  const startedAt = now();\n  let complete = false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n\n  const finish = (outcome: ViewPerformanceOutcome): void => {\n    if(complete) {\n      return;\n    }\n\n    complete = true;\n    if(timer) {\n      clearTimeout(timer);\n      timer = undefined;\n    }\n    onComplete({\n      durationMs: normalizeDuration(now() - startedAt),\n      outcome,\n      ...(route ? {route} : {}),\n      ...(title ? {title} : {}),\n      viewId\n    });\n  };\n\n  if(timeoutMs > 0) {\n    timer = setTimeout(() => finish('timeout'), timeoutMs);\n  }\n\n  return {\n    cancel: () => finish('cancelled'),\n    fail: () => finish('failure'),\n    succeed: () => finish('success'),\n    timeout: () => finish('timeout')\n  };\n};\n\nexport const reportViewPerformance = (\n  awsRum: AwsRum | undefined,\n  measurement: ViewPerformanceMeasurement\n): void => {\n  awsRum?.track({\n    name: 'view_performance',\n    ...(measurement.route ? {path: measurement.route} : {}),\n    properties: {\n      durationMs: measurement.durationMs,\n      outcome: measurement.outcome,\n      ...(measurement.title ? {viewTitle: measurement.title} : {}),\n      viewId: measurement.viewId\n    },\n    type: 'view_performance'\n  });\n};\n\nexport const useViewPerformance = ({\n  route,\n  status,\n  timeoutMs,\n  title,\n  viewId\n}: UseViewPerformanceOptions): void => {\n  const {awsRum} = useContext(GothamContext);\n  const handleRef = useRef<ViewPerformanceHandle | undefined>(undefined);\n  const statusRef = useRef(status);\n  statusRef.current = status;\n\n  useEffect(() => {\n    const handle = startView({\n      onComplete: (measurement) => reportViewPerformance(awsRum, measurement),\n      route,\n      timeoutMs,\n      title,\n      viewId\n    });\n    handleRef.current = handle;\n\n    if(statusRef.current === 'failure') {\n      handle.fail();\n    } else if(statusRef.current === 'success') {\n      handle.succeed();\n    }\n\n    return () => {\n      handle.cancel();\n      if(handleRef.current === handle) {\n        handleRef.current = undefined;\n      }\n    };\n  }, [awsRum, route, timeoutMs, title, viewId]);\n\n  useEffect(() => {\n    if(status === 'failure') {\n      handleRef.current?.fail();\n    } else if(status === 'success') {\n      handleRef.current?.succeed();\n    }\n  }, [status]);\n};\n"],"names":["useContext","useEffect","useRef","GothamContext","DEFAULT_TIMEOUT_MS","normalizeDuration","duration","Math","max","round","startView","now","globalThis","performance","Date","onComplete","route","timeoutMs","title","viewId","startedAt","complete","timer","finish","outcome","clearTimeout","undefined","durationMs","setTimeout","cancel","fail","succeed","timeout","reportViewPerformance","awsRum","measurement","track","name","path","properties","viewTitle","type","useViewPerformance","status","handleRef","statusRef","current","handle"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,UAAU,EAAEC,SAAS,EAAEC,MAAM,QAAO,QAAQ;AAEpD,SAAQC,aAAa,QAAO,qBAAqB;AAuCjD,MAAMC,qBAAqB;AAC3B,MAAMC,oBAAoB,CAACC,WAA6BC,KAAKC,GAAG,CAAC,GAAGD,KAAKE,KAAK,CAACH;AAE/E,OAAO,MAAMI,YAAY,CAAC,EACxBC,MAAM,IAAMC,WAAWC,WAAW,EAAEF,WAAWG,KAAKH,GAAG,EAAE,EACzDI,UAAU,EACVC,KAAK,EACLC,YAAYb,kBAAkB,EAC9Bc,KAAK,EACLC,MAAM,EACW;IACjB,MAAMC,YAAYT;IAClB,IAAIU,WAAW;IACf,IAAIC;IAEJ,MAAMC,SAAS,CAACC;QACd,IAAGH,UAAU;YACX;QACF;QAEAA,WAAW;QACX,IAAGC,OAAO;YACRG,aAAaH;YACbA,QAAQI;QACV;QACAX,WAAW;YACTY,YAAYtB,kBAAkBM,QAAQS;YACtCI;YACA,GAAIR,QAAQ;gBAACA;YAAK,IAAI,CAAC,CAAC;YACxB,GAAIE,QAAQ;gBAACA;YAAK,IAAI,CAAC,CAAC;YACxBC;QACF;IACF;IAEA,IAAGF,YAAY,GAAG;QAChBK,QAAQM,WAAW,IAAML,OAAO,YAAYN;IAC9C;IAEA,OAAO;QACLY,QAAQ,IAAMN,OAAO;QACrBO,MAAM,IAAMP,OAAO;QACnBQ,SAAS,IAAMR,OAAO;QACtBS,SAAS,IAAMT,OAAO;IACxB;AACF,EAAE;AAEF,OAAO,MAAMU,wBAAwB,CACnCC,QACAC;IAEAD,QAAQE,MAAM;QACZC,MAAM;QACN,GAAIF,YAAYnB,KAAK,GAAG;YAACsB,MAAMH,YAAYnB,KAAK;QAAA,IAAI,CAAC,CAAC;QACtDuB,YAAY;YACVZ,YAAYQ,YAAYR,UAAU;YAClCH,SAASW,YAAYX,OAAO;YAC5B,GAAIW,YAAYjB,KAAK,GAAG;gBAACsB,WAAWL,YAAYjB,KAAK;YAAA,IAAI,CAAC,CAAC;YAC3DC,QAAQgB,YAAYhB,MAAM;QAC5B;QACAsB,MAAM;IACR;AACF,EAAE;AAEF,OAAO,MAAMC,qBAAqB,CAAC,EACjC1B,KAAK,EACL2B,MAAM,EACN1B,SAAS,EACTC,KAAK,EACLC,MAAM,EACoB;IAC1B,MAAM,EAACe,MAAM,EAAC,GAAGlC,WAAWG;IAC5B,MAAMyC,YAAY1C,OAA0CwB;IAC5D,MAAMmB,YAAY3C,OAAOyC;IACzBE,UAAUC,OAAO,GAAGH;IAEpB1C,UAAU;QACR,MAAM8C,SAASrC,UAAU;YACvBK,YAAY,CAACoB,cAAgBF,sBAAsBC,QAAQC;YAC3DnB;YACAC;YACAC;YACAC;QACF;QACAyB,UAAUE,OAAO,GAAGC;QAEpB,IAAGF,UAAUC,OAAO,KAAK,WAAW;YAClCC,OAAOjB,IAAI;QACb,OAAO,IAAGe,UAAUC,OAAO,KAAK,WAAW;YACzCC,OAAOhB,OAAO;QAChB;QAEA,OAAO;YACLgB,OAAOlB,MAAM;YACb,IAAGe,UAAUE,OAAO,KAAKC,QAAQ;gBAC/BH,UAAUE,OAAO,GAAGpB;YACtB;QACF;IACF,GAAG;QAACQ;QAAQlB;QAAOC;QAAWC;QAAOC;KAAO;IAE5ClB,UAAU;QACR,IAAG0C,WAAW,WAAW;YACvBC,UAAUE,OAAO,EAAEhB;QACrB,OAAO,IAAGa,WAAW,WAAW;YAC9BC,UAAUE,OAAO,EAAEf;QACrB;IACF,GAAG;QAACY;KAAO;AACb,EAAE"}

package/lib/utils/viewUtils.d.ts

@@ -0,0 +1,9 @@
+import { Location, useNavigation } from 'react-router';
+export interface AppRouter {
+    readonly location: Location;
+    readonly matches: unknown[];
+    readonly navigation: ReturnType<typeof useNavigation>;
+    readonly params: unknown;
+}
+export declare const useRoute: () => AppRouter;
+export declare const parseNavUrl: (path: string, params: Record<string, unknown>) => string;

package/lib/utils/viewUtils.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { qs } from '@nlabs/utils';
+import { useMemo } from 'react';
+import { useLocation, useMatches, useNavigation, useParams } from 'react-router';
+export const useRoute = ()=>{
+    const navigation = useNavigation();
+    const location = useLocation() || {};
+    const urlParams = useParams();
+    const matches = useMatches();
+    return useMemo(()=>({
+            location,
+            matches,
+            navigation,
+            params: {
+                ...location.state || {},
+                ...urlParams,
+                ...qs.parse(location.search, {
+                    ignoreQueryPrefix: true
+                })
+            }
+        }), [
+        navigation,
+        location,
+        matches,
+        urlParams
+    ]);
+};
+export const parseNavUrl = (path, params)=>path.split('/').reduce((list, part)=>{
+        if (part?.substring(0, 1) === ':') {
+            const value = params[part.substring(1)];
+            return [
+                ...list,
+                value !== undefined ? value : part
+            ];
+        }
+        return [
+            ...list,
+            part
+        ];
+    }, []).join('/');
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy91dGlscy92aWV3VXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7cXN9IGZyb20gJ0BubGFicy91dGlscyc7XG5pbXBvcnQge3VzZU1lbW99IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7TG9jYXRpb24sIHVzZUxvY2F0aW9uLCB1c2VNYXRjaGVzLCB1c2VOYXZpZ2F0aW9uLCB1c2VQYXJhbXN9IGZyb20gJ3JlYWN0LXJvdXRlcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXBwUm91dGVyIHtcbiAgcmVhZG9ubHkgbG9jYXRpb246IExvY2F0aW9uO1xuICByZWFkb25seSBtYXRjaGVzOiB1bmtub3duW107XG4gIHJlYWRvbmx5IG5hdmlnYXRpb246IFJldHVyblR5cGU8dHlwZW9mIHVzZU5hdmlnYXRpb24+O1xuICByZWFkb25seSBwYXJhbXM6IHVua25vd247XG59XG5cbmV4cG9ydCBjb25zdCB1c2VSb3V0ZSA9ICgpOiBBcHBSb3V0ZXIgPT4ge1xuICBjb25zdCBuYXZpZ2F0aW9uID0gdXNlTmF2aWdhdGlvbigpO1xuICBjb25zdCBsb2NhdGlvbiA9IHVzZUxvY2F0aW9uKCkgfHwge30gYXMgdW5rbm93biBhcyBMb2NhdGlvbjtcbiAgY29uc3QgdXJsUGFyYW1zID0gdXNlUGFyYW1zKCk7XG4gIGNvbnN0IG1hdGNoZXMgPSB1c2VNYXRjaGVzKCk7XG5cbiAgcmV0dXJuIHVzZU1lbW8oKCkgPT4gKHtcbiAgICBsb2NhdGlvbixcbiAgICBtYXRjaGVzLFxuICAgIG5hdmlnYXRpb24sXG4gICAgcGFyYW1zOiB7XG4gICAgICAuLi4obG9jYXRpb24uc3RhdGUgfHwge30pLFxuICAgICAgLi4udXJsUGFyYW1zLFxuICAgICAgLi4ucXMucGFyc2UobG9jYXRpb24uc2VhcmNoLCB7aWdub3JlUXVlcnlQcmVmaXg6IHRydWV9KVxuICAgIH1cbiAgfSksIFtuYXZpZ2F0aW9uLCBsb2NhdGlvbiwgbWF0Y2hlcywgdXJsUGFyYW1zXSk7XG59O1xuXG5leHBvcnQgY29uc3QgcGFyc2VOYXZVcmwgPSAocGF0aDogc3RyaW5nLCBwYXJhbXM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+KTogc3RyaW5nID0+IHBhdGhcbiAgLnNwbGl0KCcvJylcbiAgLnJlZHVjZSgobGlzdDogc3RyaW5nW10sIHBhcnQ6IHN0cmluZykgPT4ge1xuICAgIGlmKHBhcnQ/LnN1YnN0cmluZygwLCAxKSA9PT0gJzonKSB7XG4gICAgICBjb25zdCB2YWx1ZSA9IHBhcmFtc1twYXJ0LnN1YnN0cmluZygxKV07XG4gICAgICByZXR1cm4gWy4uLmxpc3QsIHZhbHVlICE9PSB1bmRlZmluZWQgPyB2YWx1ZSA6IHBhcnRdIGFzIHN0cmluZ1tdO1xuICAgIH1cblxuICAgIHJldHVybiBbLi4ubGlzdCwgcGFydF07XG4gIH0sIFtdKS5qb2luKCcvJyk7XG4iXSwibmFtZXMiOlsicXMiLCJ1c2VNZW1vIiwidXNlTG9jYXRpb24iLCJ1c2VNYXRjaGVzIiwidXNlTmF2aWdhdGlvbiIsInVzZVBhcmFtcyIsInVzZVJvdXRlIiwibmF2aWdhdGlvbiIsImxvY2F0aW9uIiwidXJsUGFyYW1zIiwibWF0Y2hlcyIsInBhcmFtcyIsInN0YXRlIiwicGFyc2UiLCJzZWFyY2giLCJpZ25vcmVRdWVyeVByZWZpeCIsInBhcnNlTmF2VXJsIiwicGF0aCIsInNwbGl0IiwicmVkdWNlIiwibGlzdCIsInBhcnQiLCJzdWJzdHJpbmciLCJ2YWx1ZSIsInVuZGVmaW5lZCIsImpvaW4iXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELFNBQVFBLEVBQUUsUUFBTyxlQUFlO0FBQ2hDLFNBQVFDLE9BQU8sUUFBTyxRQUFRO0FBQzlCLFNBQWtCQyxXQUFXLEVBQUVDLFVBQVUsRUFBRUMsYUFBYSxFQUFFQyxTQUFTLFFBQU8sZUFBZTtBQVN6RixPQUFPLE1BQU1DLFdBQVc7SUFDdEIsTUFBTUMsYUFBYUg7SUFDbkIsTUFBTUksV0FBV04saUJBQWlCLENBQUM7SUFDbkMsTUFBTU8sWUFBWUo7SUFDbEIsTUFBTUssVUFBVVA7SUFFaEIsT0FBT0YsUUFBUSxJQUFPLENBQUE7WUFDcEJPO1lBQ0FFO1lBQ0FIO1lBQ0FJLFFBQVE7Z0JBQ04sR0FBSUgsU0FBU0ksS0FBSyxJQUFJLENBQUMsQ0FBQztnQkFDeEIsR0FBR0gsU0FBUztnQkFDWixHQUFHVCxHQUFHYSxLQUFLLENBQUNMLFNBQVNNLE1BQU0sRUFBRTtvQkFBQ0MsbUJBQW1CO2dCQUFJLEVBQUU7WUFDekQ7UUFDRixDQUFBLEdBQUk7UUFBQ1I7UUFBWUM7UUFBVUU7UUFBU0Q7S0FBVTtBQUNoRCxFQUFFO0FBRUYsT0FBTyxNQUFNTyxjQUFjLENBQUNDLE1BQWNOLFNBQTRDTSxLQUNuRkMsS0FBSyxDQUFDLEtBQ05DLE1BQU0sQ0FBQyxDQUFDQyxNQUFnQkM7UUFDdkIsSUFBR0EsTUFBTUMsVUFBVSxHQUFHLE9BQU8sS0FBSztZQUNoQyxNQUFNQyxRQUFRWixNQUFNLENBQUNVLEtBQUtDLFNBQVMsQ0FBQyxHQUFHO1lBQ3ZDLE9BQU87bUJBQUlGO2dCQUFNRyxVQUFVQyxZQUFZRCxRQUFRRjthQUFLO1FBQ3REO1FBRUEsT0FBTztlQUFJRDtZQUFNQztTQUFLO0lBQ3hCLEdBQUcsRUFBRSxFQUFFSSxJQUFJLENBQUMsS0FBSyJ9

package/lib/views/AuthSignInView/AuthSignInView.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { AuthViewProps } from '../AuthView/AuthView.js';
+export interface AuthSignInValues extends Record<string, unknown> {
+    readonly email: string;
+    readonly password: string;
+    readonly rememberEmail: boolean;
+}
+export interface AuthSignInViewProps extends Omit<AuthViewProps, 'cardDescription' | 'cardTitle' | 'children' | 'onSubmit'> {
+    readonly cardDescription?: ReactNode;
+    readonly cardTitle?: ReactNode;
+    readonly defaultEmail?: string;
+    readonly error?: ReactNode;
+    readonly forgotPasswordHref?: string;
+    readonly onSubmit: (values: AuthSignInValues) => void | Promise<void>;
+    readonly signUpHref?: string;
+    readonly submitClassName?: string;
+}
+declare const AuthSignInViewComponent: ({ cardDescription, cardTitle, defaultEmail, error, forgotPasswordHref, onSubmit, signUpHref, submitClassName, ...authViewProps }: AuthSignInViewProps) => import("react").JSX.Element;
+export declare const AuthSignInView: import("react").MemoExoticComponent<typeof AuthSignInViewComponent>;
+export {};

package/lib/views/AuthSignInView/AuthSignInView.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo } from 'react';
+import { z } from 'zod';
+import { Button } from '../../components/Button/Button.js';
+import { Checkbox } from '../../components/Checkbox/Checkbox.js';
+import { Form } from '../../components/Form/Form.js';
+import { Link } from '../../components/Link/Link.js';
+import { TextField } from '../../components/TextField/TextField.js';
+import { AuthView } from '../AuthView/AuthView.js';
+const authSignInSchema = z.object({
+    email: z.email('Enter a valid email address.'),
+    password: z.string().min(1, 'Enter your password.'),
+    rememberEmail: z.boolean()
+});
+const AuthSignInViewComponent = ({ cardDescription = 'Use your email and password to continue.', cardTitle = 'Sign in', defaultEmail = '', error, forgotPasswordHref = '/forgot-password', onSubmit, signUpHref = '/signup', submitClassName, ...authViewProps })=>/*#__PURE__*/ _jsxs(AuthView, {
+        cardDescription: cardDescription,
+        cardTitle: cardTitle,
+        ...authViewProps,
+        children: [
+            error ? /*#__PURE__*/ _jsx("div", {
+                className: "mb-5 rounded-lg border border-error-300 bg-error-50 p-3 text-sm text-error-700",
+                role: "alert",
+                children: error
+            }) : null,
+            /*#__PURE__*/ _jsx(Form, {
+                className: "grid",
+                defaultValues: {
+                    email: defaultEmail,
+                    password: '',
+                    rememberEmail: true
+                },
+                name: "sign-in",
+                onSubmit: onSubmit,
+                schema: authSignInSchema,
+                showErrors: true,
+                children: ({ formState })=>/*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "grid gap-7 max-[600px]:gap-6",
+                                children: [
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        autoComplete: "email",
+                                        borderColor: "neutral",
+                                        borderType: "underline",
+                                        inputClass: "min-h-12 rounded-none border-x-0 border-t-0 bg-transparent px-0 text-base shadow-none",
+                                        label: "Email",
+                                        labelClass: "mb-2 text-sm font-bold",
+                                        name: "email",
+                                        placeholder: "you@example.com",
+                                        type: "email"
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        autoComplete: "current-password",
+                                        borderColor: "neutral",
+                                        borderType: "underline",
+                                        inputClass: "min-h-12 rounded-none border-x-0 border-t-0 bg-transparent px-0 pr-11 text-base shadow-none",
+                                        label: "Password",
+                                        labelClass: "mb-2 text-sm font-bold",
+                                        name: "password",
+                                        placeholder: "Your password",
+                                        showPasswordToggle: true,
+                                        type: "password"
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "my-5 flex items-center justify-between gap-4",
+                                children: [
+                                    /*#__PURE__*/ _jsx(Checkbox, {
+                                        defaultValue: true,
+                                        label: "Remember me",
+                                        name: "rememberEmail"
+                                    }),
+                                    /*#__PURE__*/ _jsx(Link, {
+                                        className: "text-sm font-bold no-underline",
+                                        href: forgotPasswordHref,
+                                        children: "Forgot password?"
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                className: submitClassName,
+                                disabled: formState.isSubmitting,
+                                isLoading: formState.isSubmitting,
+                                type: "submit",
+                                children: "Sign In"
+                            })
+                        ]
+                    })
+            }),
+            /*#__PURE__*/ _jsxs("p", {
+                className: "mb-0 mt-6 text-sm text-muted-foreground dark:text-muted-foreground-dark",
+                children: [
+                    "New here? ",
+                    /*#__PURE__*/ _jsx(Link, {
+                        className: "font-bold no-underline",
+                        href: signUpHref,
+                        children: "Sign Up"
+                    })
+                ]
+            })
+        ]
+    });
+export const AuthSignInView = /*#__PURE__*/ memo(AuthSignInViewComponent);
+AuthSignInView.displayName = 'AuthSignInView';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/views/AuthSignInView/AuthSignInView.tsx"],"sourcesContent":["import {memo} from 'react';\nimport {z} from 'zod';\n\nimport {Button} from '../../components/Button/Button.js';\nimport {Checkbox} from '../../components/Checkbox/Checkbox.js';\nimport {Form} from '../../components/Form/Form.js';\nimport {Link} from '../../components/Link/Link.js';\nimport {TextField} from '../../components/TextField/TextField.js';\nimport {AuthView} from '../AuthView/AuthView.js';\n\nimport type {ReactNode} from 'react';\nimport type {AuthViewProps} from '../AuthView/AuthView.js';\n\nexport interface AuthSignInValues extends Record<string, unknown> {\n  readonly email: string;\n  readonly password: string;\n  readonly rememberEmail: boolean;\n}\n\nexport interface AuthSignInViewProps extends Omit<AuthViewProps, 'cardDescription' | 'cardTitle' | 'children' | 'onSubmit'> {\n  readonly cardDescription?: ReactNode;\n  readonly cardTitle?: ReactNode;\n  readonly defaultEmail?: string;\n  readonly error?: ReactNode;\n  readonly forgotPasswordHref?: string;\n  readonly onSubmit: (values: AuthSignInValues) => void | Promise<void>;\n  readonly signUpHref?: string;\n  readonly submitClassName?: string;\n}\n\nconst authSignInSchema = z.object({\n  email: z.email('Enter a valid email address.'),\n  password: z.string().min(1, 'Enter your password.'),\n  rememberEmail: z.boolean()\n});\n\nconst AuthSignInViewComponent = ({\n  cardDescription = 'Use your email and password to continue.',\n  cardTitle = 'Sign in',\n  defaultEmail = '',\n  error,\n  forgotPasswordHref = '/forgot-password',\n  onSubmit,\n  signUpHref = '/signup',\n  submitClassName,\n  ...authViewProps\n}: AuthSignInViewProps) => (\n  <AuthView cardDescription={cardDescription} cardTitle={cardTitle} {...authViewProps}>\n    {error ? (\n      <div className=\"mb-5 rounded-lg border border-error-300 bg-error-50 p-3 text-sm text-error-700\" role=\"alert\">\n        {error}\n      </div>\n    ) : null}\n    <Form<AuthSignInValues>\n      className=\"grid\"\n      defaultValues={{email: defaultEmail, password: '', rememberEmail: true}}\n      name=\"sign-in\"\n      onSubmit={onSubmit}\n      schema={authSignInSchema}\n      showErrors\n    >\n      {({formState}) => (\n        <>\n          <div className=\"grid gap-7 max-[600px]:gap-6\">\n            <TextField\n              autoComplete=\"email\"\n              borderColor=\"neutral\"\n              borderType=\"underline\"\n              inputClass=\"min-h-12 rounded-none border-x-0 border-t-0 bg-transparent px-0 text-base shadow-none\"\n              label=\"Email\"\n              labelClass=\"mb-2 text-sm font-bold\"\n              name=\"email\"\n              placeholder=\"you@example.com\"\n              type=\"email\"\n            />\n            <TextField\n              autoComplete=\"current-password\"\n              borderColor=\"neutral\"\n              borderType=\"underline\"\n              inputClass=\"min-h-12 rounded-none border-x-0 border-t-0 bg-transparent px-0 pr-11 text-base shadow-none\"\n              label=\"Password\"\n              labelClass=\"mb-2 text-sm font-bold\"\n              name=\"password\"\n              placeholder=\"Your password\"\n              showPasswordToggle\n              type=\"password\"\n            />\n          </div>\n          <div className=\"my-5 flex items-center justify-between gap-4\">\n            <Checkbox defaultValue label=\"Remember me\" name=\"rememberEmail\" />\n            <Link className=\"text-sm font-bold no-underline\" href={forgotPasswordHref}>Forgot password?</Link>\n          </div>\n          <Button\n            className={submitClassName}\n            disabled={formState.isSubmitting}\n            isLoading={formState.isSubmitting}\n            type=\"submit\"\n          >\n            Sign In\n          </Button>\n        </>\n      )}\n    </Form>\n    <p className=\"mb-0 mt-6 text-sm text-muted-foreground dark:text-muted-foreground-dark\">\n      New here? <Link className=\"font-bold no-underline\" href={signUpHref}>Sign Up</Link>\n    </p>\n  </AuthView>\n);\n\nexport const AuthSignInView = memo(AuthSignInViewComponent);\nAuthSignInView.displayName = 'AuthSignInView';\n"],"names":["memo","z","Button","Checkbox","Form","Link","TextField","AuthView","authSignInSchema","object","email","password","string","min","rememberEmail","boolean","AuthSignInViewComponent","cardDescription","cardTitle","defaultEmail","error","forgotPasswordHref","onSubmit","signUpHref","submitClassName","authViewProps","div","className","role","defaultValues","name","schema","showErrors","formState","autoComplete","borderColor","borderType","inputClass","label","labelClass","placeholder","type","showPasswordToggle","defaultValue","href","disabled","isSubmitting","isLoading","p","AuthSignInView","displayName"],"mappings":";AAAA,SAAQA,IAAI,QAAO,QAAQ;AAC3B,SAAQC,CAAC,QAAO,MAAM;AAEtB,SAAQC,MAAM,QAAO,oCAAoC;AACzD,SAAQC,QAAQ,QAAO,wCAAwC;AAC/D,SAAQC,IAAI,QAAO,gCAAgC;AACnD,SAAQC,IAAI,QAAO,gCAAgC;AACnD,SAAQC,SAAS,QAAO,0CAA0C;AAClE,SAAQC,QAAQ,QAAO,0BAA0B;AAsBjD,MAAMC,mBAAmBP,EAAEQ,MAAM,CAAC;IAChCC,OAAOT,EAAES,KAAK,CAAC;IACfC,UAAUV,EAAEW,MAAM,GAAGC,GAAG,CAAC,GAAG;IAC5BC,eAAeb,EAAEc,OAAO;AAC1B;AAEA,MAAMC,0BAA0B,CAAC,EAC/BC,kBAAkB,0CAA0C,EAC5DC,YAAY,SAAS,EACrBC,eAAe,EAAE,EACjBC,KAAK,EACLC,qBAAqB,kBAAkB,EACvCC,QAAQ,EACRC,aAAa,SAAS,EACtBC,eAAe,EACf,GAAGC,eACiB,iBACpB,MAAClB;QAASU,iBAAiBA;QAAiBC,WAAWA;QAAY,GAAGO,aAAa;;YAChFL,sBACC,KAACM;gBAAIC,WAAU;gBAAiFC,MAAK;0BAClGR;iBAED;0BACJ,KAAChB;gBACCuB,WAAU;gBACVE,eAAe;oBAACnB,OAAOS;oBAAcR,UAAU;oBAAIG,eAAe;gBAAI;gBACtEgB,MAAK;gBACLR,UAAUA;gBACVS,QAAQvB;gBACRwB,UAAU;0BAET,CAAC,EAACC,SAAS,EAAC,iBACX;;0CACE,MAACP;gCAAIC,WAAU;;kDACb,KAACrB;wCACC4B,cAAa;wCACbC,aAAY;wCACZC,YAAW;wCACXC,YAAW;wCACXC,OAAM;wCACNC,YAAW;wCACXT,MAAK;wCACLU,aAAY;wCACZC,MAAK;;kDAEP,KAACnC;wCACC4B,cAAa;wCACbC,aAAY;wCACZC,YAAW;wCACXC,YAAW;wCACXC,OAAM;wCACNC,YAAW;wCACXT,MAAK;wCACLU,aAAY;wCACZE,kBAAkB;wCAClBD,MAAK;;;;0CAGT,MAACf;gCAAIC,WAAU;;kDACb,KAACxB;wCAASwC,YAAY;wCAACL,OAAM;wCAAcR,MAAK;;kDAChD,KAACzB;wCAAKsB,WAAU;wCAAiCiB,MAAMvB;kDAAoB;;;;0CAE7E,KAACnB;gCACCyB,WAAWH;gCACXqB,UAAUZ,UAAUa,YAAY;gCAChCC,WAAWd,UAAUa,YAAY;gCACjCL,MAAK;0CACN;;;;;0BAMP,MAACO;gBAAErB,WAAU;;oBAA0E;kCAC3E,KAACtB;wBAAKsB,WAAU;wBAAyBiB,MAAMrB;kCAAY;;;;;;AAK3E,OAAO,MAAM0B,+BAAiBjD,KAAKgB,yBAAyB;AAC5DiC,eAAeC,WAAW,GAAG"}

package/lib/views/AuthSignInView/AuthSignInView.stories.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { AuthSignInView } from './AuthSignInView.js';
+const meta = {
+    component: AuthSignInView,
+    parameters: {
+        layout: 'fullscreen'
+    },
+    title: 'Views/Auth/AuthSignInView'
+};
+export default meta;
+export const Default = {
+    args: {
+        description: 'Sign in once to return to everything your account can access.',
+        eyebrow: 'Acme identity',
+        onSubmit: async ()=>{},
+        title: /*#__PURE__*/ _jsxs(_Fragment, {
+            children: [
+                "Welcome",
+                /*#__PURE__*/ _jsx("br", {}),
+                "back."
+            ]
+        })
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy92aWV3cy9BdXRoU2lnbkluVmlldy9BdXRoU2lnbkluVmlldy5zdG9yaWVzLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuXG5pbXBvcnQge2ludGVyYWN0V2l0aENhbnZhc30gZnJvbSAnLi4vLi4vdXRpbHMvc3RvcnlJbnRlcmFjdGlvbnMuanMnO1xuaW1wb3J0IHtBdXRoU2lnbkluVmlld30gZnJvbSAnLi9BdXRoU2lnbkluVmlldy5qcyc7XG5cbmltcG9ydCB0eXBlIHtNZXRhLCBTdG9yeU9ian0gZnJvbSAnQG5sYWJzL2xleC9zdG9yeWJvb2snO1xuXG5jb25zdCBtZXRhOiBNZXRhPHR5cGVvZiBBdXRoU2lnbkluVmlldz4gPSB7XG4gIGNvbXBvbmVudDogQXV0aFNpZ25JblZpZXcsXG4gIHBhcmFtZXRlcnM6IHtcbiAgICBsYXlvdXQ6ICdmdWxsc2NyZWVuJ1xuICB9LFxuICB0aXRsZTogJ1ZpZXdzL0F1dGgvQXV0aFNpZ25JblZpZXcnXG59O1xuXG5leHBvcnQgZGVmYXVsdCBtZXRhO1xuXG50eXBlIFN0b3J5ID0gU3RvcnlPYmo8dHlwZW9mIEF1dGhTaWduSW5WaWV3PjtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHQ6IFN0b3J5ID0ge1xuICBhcmdzOiB7XG4gICAgZGVzY3JpcHRpb246ICdTaWduIGluIG9uY2UgdG8gcmV0dXJuIHRvIGV2ZXJ5dGhpbmcgeW91ciBhY2NvdW50IGNhbiBhY2Nlc3MuJyxcbiAgICBleWVicm93OiAnQWNtZSBpZGVudGl0eScsXG4gICAgb25TdWJtaXQ6IGFzeW5jICgpID0+IHt9LFxuICAgIHRpdGxlOiA8PldlbGNvbWU8YnIgLz5iYWNrLjwvPlxuICB9LFxuICBwbGF5OiBpbnRlcmFjdFdpdGhDYW52YXNcbn07XG4iXSwibmFtZXMiOlsiUmVhY3QiLCJpbnRlcmFjdFdpdGhDYW52YXMiLCJBdXRoU2lnbkluVmlldyIsIm1ldGEiLCJjb21wb25lbnQiLCJwYXJhbWV0ZXJzIiwibGF5b3V0IiwidGl0bGUiLCJEZWZhdWx0IiwiYXJncyIsImRlc2NyaXB0aW9uIiwiZXllYnJvdyIsIm9uU3VibWl0IiwiYnIiLCJwbGF5Il0sIm1hcHBpbmdzIjoiO0FBQUEsT0FBT0EsV0FBVyxRQUFRO0FBRTFCLFNBQVFDLGtCQUFrQixRQUFPLG1DQUFtQztBQUNwRSxTQUFRQyxjQUFjLFFBQU8sc0JBQXNCO0FBSW5ELE1BQU1DLE9BQW9DO0lBQ3hDQyxXQUFXRjtJQUNYRyxZQUFZO1FBQ1ZDLFFBQVE7SUFDVjtJQUNBQyxPQUFPO0FBQ1Q7QUFFQSxlQUFlSixLQUFLO0FBSXBCLE9BQU8sTUFBTUssVUFBaUI7SUFDNUJDLE1BQU07UUFDSkMsYUFBYTtRQUNiQyxTQUFTO1FBQ1RDLFVBQVUsV0FBYTtRQUN2QkwscUJBQU87O2dCQUFFOzhCQUFPLEtBQUNNO2dCQUFLOzs7SUFDeEI7SUFDQUMsTUFBTWI7QUFDUixFQUFFIn0=

package/lib/views/AuthSignUpView/AuthSignUpView.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import type { AuthViewProps } from '../AuthView/AuthView.js';
+export interface AuthSignUpValues extends Record<string, unknown> {
+    readonly acceptTerms: boolean;
+    readonly confirmPassword: string;
+    readonly email: string;
+    readonly password: string;
+}
+export interface AuthSignUpViewProps extends Omit<AuthViewProps, 'cardDescription' | 'cardTitle' | 'children' | 'onSubmit'> {
+    readonly cardDescription?: ReactNode;
+    readonly cardTitle?: ReactNode;
+    readonly error?: ReactNode;
+    readonly onSubmit: (values: AuthSignUpValues) => void | Promise<void>;
+    readonly resendVerificationHref?: string;
+    readonly signInHref?: string;
+    readonly submitClassName?: string;
+    readonly termsHref?: string;
+}
+declare const AuthSignUpViewComponent: ({ cardClassName, cardDescription, cardHeaderClassName, cardTitle, error, onSubmit, resendVerificationHref, signInHref, submitClassName, termsHref, ...authViewProps }: AuthSignUpViewProps) => import("react").JSX.Element;
+export declare const AuthSignUpView: import("react").MemoExoticComponent<typeof AuthSignUpViewComponent>;
+export {};