frontend-hamroun 1.2.84 → 1.2.88

package/dist/batch.d.ts

@@ -0,0 +1,4 @@
+export declare let isBatching: boolean;
+export declare function batchUpdates(fn: Function): void;
+export declare function getIsBatching(): boolean;
+//# sourceMappingURL=batch.d.ts.map

package/dist/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../src/batch.ts"],"names":[],"mappings":"AAAA,eAAO,IAAI,UAAU,SAAQ,CAAC;AAG9B,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,QAgBxC;AAED,wBAAgB,aAAa,YAE5B"}

package/dist/batch.js

@@ -0,0 +1,22 @@
+export let isBatching = false;
+const queue = [];
+export function batchUpdates(fn) {
+    if (isBatching) {
+        queue.push(fn);
+        return;
+    }
+    isBatching = true;
+    try {
+        fn();
+        while (queue.length > 0) {
+            const nextFn = queue.shift();
+            nextFn?.();
+        }
+    }
+    finally {
+        isBatching = false;
+    }
+}
+export function getIsBatching() {
+    return isBatching;
+}

package/dist/client-router.d.ts

@@ -0,0 +1,61 @@
+export interface Route {
+    path: string;
+    component: any;
+    props?: Record<string, any>;
+    exact?: boolean;
+}
+export interface RouterState {
+    location: {
+        pathname: string;
+        search: string;
+        hash: string;
+    };
+    params: Record<string, string>;
+    navigate: (to: string, options?: NavigateOptions) => void;
+    match: (path: string) => boolean;
+}
+export interface NavigateOptions {
+    replace?: boolean;
+    state?: any;
+}
+export declare const RouterContext: import("./types.js").Context<RouterState>;
+export declare function RouterProvider({ routes, children }: {
+    routes: Route[];
+    children: any;
+}): any;
+export declare function Route({ path, component: Component, props }: Route): any;
+export declare function Switch({ children }: {
+    children: any;
+}): any;
+export declare function Link({ to, replace, state, className, activeClassName, children, ...rest }: {
+    to: string;
+    replace?: boolean;
+    state?: any;
+    className?: string;
+    activeClassName?: string;
+    children: any;
+    [key: string]: any;
+}): any;
+export declare function Redirect({ to, replace }: {
+    to: string;
+    replace?: boolean;
+}): null;
+export declare function useLocation(): {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare function useParams(): Record<string, string>;
+export declare function useNavigate(): (to: string, options?: NavigateOptions) => void;
+declare const _default: {
+    RouterProvider: typeof RouterProvider;
+    Route: typeof Route;
+    Switch: typeof Switch;
+    Link: typeof Link;
+    Redirect: typeof Redirect;
+    useLocation: typeof useLocation;
+    useParams: typeof useParams;
+    useNavigate: typeof useNavigate;
+};
+export default _default;
+//# sourceMappingURL=client-router.d.ts.map

package/dist/client-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-router.d.ts","sourceRoot":"","sources":["../src/client-router.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,GAAG,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC;IAC1D,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;AAGD,eAAO,MAAM,aAAa,2CASxB,CAAC;AAyCH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,GAAG,GAAG,CA0F5F;AAGD,wBAAgB,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,KAAU,EAAE,EAAE,KAAK,GAAG,GAAG,CAW5E;AAGD,wBAAgB,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAA;CAAE,OAoBrD;AAGD,wBAAgB,IAAI,CAAC,EACnB,EAAE,EACF,OAAe,EACf,KAAY,EACZ,SAAc,EACd,eAAoB,EACpB,QAAQ,EACR,GAAG,IAAI,EACR,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,GAAG,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,GAAG,GAAG,CAuBN;AAGD,wBAAgB,QAAQ,CAAC,EAAE,EAAE,EAAE,OAAc,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,QASjF;AAGD,wBAAgB,WAAW;cAzPb,MAAM;YACR,MAAM;UACR,MAAM;EA0Pf;AAED,wBAAgB,SAAS,2BAGxB;AAED,wBAAgB,WAAW,SA9PV,MAAM,YAAY,eAAe,KAAK,IAAI,CAiQ1D;;;;;;;;;;;AAED,wBASE"}

package/dist/client-router.js

@@ -0,0 +1,209 @@
+/**
+ * Client-side router for single-page applications
+ */
+import { useState, useEffect } from './hooks.js';
+import { createContext, useContext } from './context.js';
+import { jsx } from './jsx-runtime.js';
+// Create context for router
+export const RouterContext = createContext({
+    location: {
+        pathname: '/',
+        search: '',
+        hash: ''
+    },
+    params: {},
+    navigate: () => { },
+    match: () => false
+});
+// Parse path pattern into regex
+function parsePath(path) {
+    // Convert :param syntax to capture groups
+    const pattern = path
+        .replace(/\/+$/, '') // Remove trailing slashes
+        .replace(/^\/+/, '/') // Ensure leading slash
+        .replace(/\/:([^/]+)/g, '/([^/]+)');
+    // Get param names
+    const paramNames = [];
+    path.replace(/\/:([^/]+)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '';
+    });
+    return { pattern, paramNames };
+}
+// Match a path against a pattern
+function matchPath(pathname, route) {
+    const { path, exact = false } = route;
+    const { pattern, paramNames } = parsePath(path);
+    // Create regex with or without exact matching
+    const regex = new RegExp(`^${pattern}${exact ? '$' : ''}`);
+    const match = pathname.match(regex);
+    if (!match)
+        return null;
+    // Extract params
+    const params = {};
+    paramNames.forEach((name, index) => {
+        params[name] = match[index + 1];
+    });
+    return params;
+}
+// Router Provider component
+export function RouterProvider({ routes, children }) {
+    // Get initial location from window if available
+    const getInitialLocation = () => {
+        if (typeof window === 'undefined') {
+            return { pathname: '/', search: '', hash: '' };
+        }
+        return {
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash
+        };
+    };
+    // Fix: Call the function to get the initial value instead of passing the function itself
+    const [location, setLocation] = useState(getInitialLocation());
+    const [params, setParams] = useState({});
+    // Update params when location changes
+    useEffect(() => {
+        for (const route of routes) {
+            const matchedParams = matchPath(location.pathname, route);
+            if (matchedParams) {
+                setParams(matchedParams);
+                break;
+            }
+        }
+    }, [location, routes]);
+    // Listen for popstate events
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handlePopState = () => {
+            setLocation({
+                pathname: window.location.pathname,
+                search: window.location.search,
+                hash: window.location.hash
+            });
+        };
+        window.addEventListener('popstate', handlePopState);
+        return () => window.removeEventListener('popstate', handlePopState);
+    }, []);
+    // Navigation function
+    const navigate = (to, options = {}) => {
+        if (typeof window === 'undefined')
+            return;
+        const { replace = false, state = null } = options;
+        if (replace) {
+            window.history.replaceState(state, '', to);
+        }
+        else {
+            window.history.pushState(state, '', to);
+        }
+        // Update location
+        setLocation({
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash
+        });
+    };
+    // Match function to test if a path matches the current location
+    const match = (path) => {
+        const { pattern } = parsePath(path);
+        const regex = new RegExp(`^${pattern}`);
+        return regex.test(location.pathname);
+    };
+    // Router context value
+    const routerValue = {
+        location: {
+            pathname: location.pathname,
+            search: location.search,
+            hash: location.hash
+        },
+        params,
+        navigate,
+        match
+    };
+    return jsx(RouterContext.Provider, { value: routerValue, children });
+}
+// Route component
+export function Route({ path, component: Component, props = {} }) {
+    const context = useContext(RouterContext);
+    const params = context.params;
+    const locationPathname = context.location.pathname;
+    const routeToMatch = { path, component: Component };
+    const match = matchPath(locationPathname, routeToMatch);
+    if (!match)
+        return null;
+    return jsx(Component, { ...props, params });
+}
+// Switch component
+export function Switch({ children }) {
+    const context = useContext(RouterContext);
+    const locationPathname = context.location.pathname;
+    // Find the first matching route
+    const child = Array.isArray(children)
+        ? children.find(child => {
+            if (!child || typeof child.type !== 'function' || !child.props.path)
+                return false;
+            const routeObj = {
+                path: child.props.path,
+                component: child.type,
+                exact: child.props.exact || false
+            };
+            return matchPath(locationPathname, routeObj);
+        })
+        : children;
+    return child || null;
+}
+// Link component
+export function Link({ to, replace = false, state = null, className = '', activeClassName = '', children, ...rest }) {
+    const context = useContext(RouterContext);
+    const navigate = context.navigate;
+    const match = context.match;
+    const handleClick = (e) => {
+        e.preventDefault();
+        navigate(to, { replace, state });
+    };
+    const isActive = match(to);
+    const classes = [
+        className,
+        isActive ? activeClassName : ''
+    ].filter(Boolean).join(' ');
+    return jsx('a', {
+        href: to,
+        className: classes || undefined,
+        onClick: handleClick,
+        ...rest,
+        children
+    });
+}
+// Redirect component
+export function Redirect({ to, replace = true }) {
+    const context = useContext(RouterContext);
+    const navigate = context.navigate;
+    useEffect(() => {
+        navigate(to, { replace });
+    }, [to]);
+    return null;
+}
+// Hooks
+export function useLocation() {
+    const context = useContext(RouterContext);
+    return context.location;
+}
+export function useParams() {
+    const context = useContext(RouterContext);
+    return context.params;
+}
+export function useNavigate() {
+    const context = useContext(RouterContext);
+    return context.navigate;
+}
+export default {
+    RouterProvider,
+    Route,
+    Switch,
+    Link,
+    Redirect,
+    useLocation,
+    useParams,
+    useNavigate
+};

package/dist/component.d.ts

@@ -0,0 +1,15 @@
+export declare class Component {
+    state: any;
+    props: any;
+    element: HTMLElement | null;
+    private _mounted;
+    constructor(props?: any);
+    componentDidMount(): void;
+    setState(newState: any): Promise<void>;
+    private _replayEvents;
+    private _deepCloneWithEvents;
+    update(): Promise<HTMLElement | Text>;
+    private _updateElement;
+    render(): any;
+}
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAEA,qBAAa,SAAS;IACpB,KAAK,EAAE,GAAG,CAAM;IAChB,KAAK,EAAE,GAAG,CAAC;IACX,OAAO,EAAE,WAAW,GAAG,IAAI,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,KAAK,GAAE,GAAQ;IAI3B,iBAAiB;IAIX,QAAQ,CAAC,QAAQ,EAAE,GAAG;IAgB5B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,oBAAoB;IAsBtB,MAAM;YAcE,cAAc;IAkB5B,MAAM,IAAI,GAAG;CAGd"}

package/dist/component.js

@@ -0,0 +1,84 @@
+import { createElement } from './jsx-runtime.js';
+export class Component {
+    constructor(props = {}) {
+        this.state = {};
+        this.element = null;
+        this._mounted = false;
+        this.props = props;
+    }
+    componentDidMount() {
+        // Hook for after component is mounted
+    }
+    async setState(newState) {
+        const prevState = { ...this.state };
+        this.state = { ...prevState, ...newState };
+        console.log(`${this.constructor.name} state updated:`, {
+            prev: prevState,
+            next: this.state
+        });
+        await Promise.resolve(); // Ensure state is updated before re-render
+        if (this._mounted) {
+            await this.update();
+        }
+        else {
+            await this.update();
+        }
+    }
+    _replayEvents(oldElement, newElement) {
+        const oldEvents = oldElement.__events || {};
+        Object.entries(oldEvents).forEach(([event, handler]) => {
+            newElement.addEventListener(event, handler);
+        });
+        newElement.__events = oldEvents;
+    }
+    _deepCloneWithEvents(node) {
+        const clone = node.cloneNode(false);
+        // Copy events from original element
+        const events = node.__events || {};
+        clone.__events = events;
+        Object.entries(events).forEach(([event, handler]) => {
+            clone.addEventListener(event, handler);
+        });
+        // Clone children
+        Array.from(node.childNodes).forEach(child => {
+            if (child instanceof HTMLElement) {
+                clone.appendChild(this._deepCloneWithEvents(child));
+            }
+            else {
+                clone.appendChild(child.cloneNode(true));
+            }
+        });
+        return clone;
+    }
+    async update() {
+        const vdom = this.render();
+        if (!vdom)
+            return document.createTextNode('');
+        const rendered = await createElement(vdom);
+        if (rendered instanceof HTMLElement) {
+            return this._updateElement(rendered);
+        }
+        const wrapper = document.createElement('div');
+        wrapper.appendChild(rendered);
+        return this._updateElement(wrapper);
+    }
+    async _updateElement(rendered) {
+        const newElement = this._deepCloneWithEvents(rendered);
+        newElement.__instance = this;
+        if (!this.element) {
+            this.element = newElement;
+            if (!this._mounted) {
+                this._mounted = true;
+                queueMicrotask(() => this.componentDidMount());
+            }
+        }
+        else if (this.element.parentNode) {
+            this.element.parentNode.replaceChild(newElement, this.element);
+            this.element = newElement;
+        }
+        return this.element;
+    }
+    render() {
+        throw new Error('Component must implement render() method');
+    }
+}

package/dist/components/Counter.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=Counter.d.ts.map

package/dist/components/Counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Counter.d.ts","sourceRoot":"","sources":["../../src/components/Counter.tsx"],"names":[],"mappings":""}

package/dist/components/Counter.js

@@ -0,0 +1,2 @@
+"use strict";
+// ...existing code...import { useState, useEffect } from '../index';

package/dist/context.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from './types.js';
+export declare function createContext<T>(defaultValue: T): Context<T>;
+export declare function useContext<T>(context: Context<T>): T;
+export type { Context } from './types.js';
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,YAAY,CAAC;AAIzD,wBAAgB,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAoB5D;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAIpD;AAGD,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/dist/context.js

@@ -0,0 +1,23 @@
+const contexts = new Map();
+export function createContext(defaultValue) {
+    const contextId = Symbol('context');
+    const Provider = ({ value, children }) => {
+        contexts.set(contextId, value);
+        return children;
+    };
+    const Consumer = ({ children }) => {
+        const value = contexts.get(contextId) ?? defaultValue;
+        return children(value);
+    };
+    const context = {
+        Provider,
+        Consumer,
+        displayName: 'Context'
+    };
+    return context;
+}
+export function useContext(context) {
+    // In a real implementation, this would access the context value from the component tree
+    // For now, returning a default value to satisfy TypeScript
+    return {};
+}

package/dist/event-bus.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Event bus for communication between components
+ */
+export type EventHandler = (...args: any[]) => void;
+export interface EventBus {
+    on(event: string, handler: EventHandler): () => void;
+    once(event: string, handler: EventHandler): () => void;
+    off(event: string, handler?: EventHandler): void;
+    emit(event: string, ...args: any[]): void;
+    clear(event?: string): void;
+}
+export declare function createEventBus(): EventBus;
+declare const globalEventBus: EventBus;
+export declare function useEvent(event: string, handler: EventHandler, options?: {
+    once?: boolean;
+}): () => void;
+export { globalEventBus as eventBus };
+declare const _default: {
+    createEventBus: typeof createEventBus;
+    eventBus: EventBus;
+    useEvent: typeof useEvent;
+};
+export default _default;
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../src/event-bus.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAEpD,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI,CAAC;IACrD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI,CAAC;IACvD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACjD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC1C,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAyEzC;AAGD,QAAA,MAAM,cAAc,UAAmB,CAAC;AAGxC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,SAtF7C,IAAI,CA0FrD;AAED,OAAO,EAAE,cAAc,IAAI,QAAQ,EAAE,CAAC;;;;;;AAEtC,wBAIE"}

package/dist/event-bus.js

@@ -0,0 +1,74 @@
+export function createEventBus() {
+    const events = new Map();
+    const onceHandlers = new WeakMap();
+    const on = (event, handler) => {
+        if (!events.has(event)) {
+            events.set(event, new Set());
+        }
+        events.get(event).add(handler);
+        // Return a function to remove this handler
+        return () => off(event, handler);
+    };
+    const once = (event, handler) => {
+        // Create a wrapper that will call the handler and remove itself
+        const onceWrapper = (...args) => {
+            off(event, onceWrapper);
+            handler(...args);
+        };
+        // Store the mapping between the original handler and the wrapper
+        onceHandlers.set(handler, onceWrapper);
+        // Register the wrapper
+        return on(event, onceWrapper);
+    };
+    const off = (event, handler) => {
+        // If no handler is provided, remove all handlers for the event
+        if (!handler) {
+            events.delete(event);
+            return;
+        }
+        // Check if it's a once handler wrapper
+        const wrappedHandler = onceHandlers.get(handler);
+        const handlerToRemove = wrappedHandler || handler;
+        if (events.has(event)) {
+            events.get(event).delete(handlerToRemove);
+            // Clean up empty event sets
+            if (events.get(event).size === 0) {
+                events.delete(event);
+            }
+        }
+    };
+    const emit = (event, ...args) => {
+        if (!events.has(event)) {
+            return;
+        }
+        // Create a copy of the handlers to avoid issues if handlers modify the set
+        const handlers = Array.from(events.get(event));
+        // Call each handler with the arguments
+        for (const handler of handlers) {
+            handler(...args);
+        }
+    };
+    const clear = (event) => {
+        if (event) {
+            events.delete(event);
+        }
+        else {
+            events.clear();
+        }
+    };
+    return { on, once, off, emit, clear };
+}
+// Create a global event bus instance
+const globalEventBus = createEventBus();
+// Hook to use the event bus in components
+export function useEvent(event, handler, options = {}) {
+    return options.once
+        ? globalEventBus.once(event, handler)
+        : globalEventBus.on(event, handler);
+}
+export { globalEventBus as eventBus };
+export default {
+    createEventBus,
+    eventBus: globalEventBus,
+    useEvent
+};

package/dist/forms.d.ts

@@ -0,0 +1,41 @@
+export interface FormField {
+    value: any;
+    error?: string;
+    touched: boolean;
+    dirty: boolean;
+}
+export interface FormState {
+    fields: Record<string, FormField>;
+    isValid: boolean;
+    isDirty: boolean;
+    isSubmitting: boolean;
+    submitCount: number;
+}
+export interface FormOptions<T> {
+    initialValues: T;
+    validate?: (values: T) => Record<string, string>;
+    onSubmit?: (values: T, form: FormState) => void | Promise<void>;
+}
+export interface FormConfig<T> {
+    values: T;
+    errors: Record<string, string>;
+    touched: Record<string, boolean>;
+    dirty: Record<string, boolean>;
+    isValid: boolean;
+    isDirty: boolean;
+    isSubmitting: boolean;
+    submitCount: number;
+    handleChange: (e: any) => void;
+    handleBlur: (e: any) => void;
+    handleSubmit: (e: any) => void;
+    setFieldValue: (field: string, value: any) => void;
+    setFieldError: (field: string, error: string) => void;
+    setValues: (values: Partial<T>) => void;
+    resetForm: () => void;
+}
+export declare function useForm<T extends Record<string, any>>(options: FormOptions<T>): FormConfig<T>;
+declare const _default: {
+    useForm: typeof useForm;
+};
+export default _default;
+//# sourceMappingURL=forms.d.ts.map

package/dist/forms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms.d.ts","sourceRoot":"","sources":["../src/forms.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,aAAa,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC;IACV,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC7B,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACnD,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACxC,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA+J7F;;;;AAED,wBAEE"}