asasvirtuais 2.3.0 → 2.3.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "asasvirtuais",
   "type": "module",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "React form and action management utilities",
   "directories": {
     "packages": "./packages"

package/packages/action.tsx

@@ -5,7 +5,7 @@ export type ActionProps<Params, Result> = {
   params: Partial<Params>
   action: (fields: Params) => Promise<Result>
   onResult?: (result: Result) => any
-  onError?: (error: Error) => any 
+  onError?: (error: Error) => any
   autoTrigger?: boolean
 }
 
@@ -14,11 +14,6 @@ export function useActionProvider<Fields, Result>(props: React.PropsWithChildren
   const [error, setError] = useState<Error | null>(null)
   const [result, setResult] = useState<Result | null>(null)
 
-  useEffect(() => {
-    if (props.autoTrigger)
-      props.action(props.params as Fields)
-  }, [])
-
   /** receives an event (optional) and processes the form submission using the fields state as props, stores the result or error in the respective states */
   const submit = useCallback(
     async (e?: any) => {
@@ -44,20 +39,46 @@ export function useActionProvider<Fields, Result>(props: React.PropsWithChildren
     [props.params, props.action, props.onError]
   )
 
+  const callback = useCallback(async (fields: Fields) => {
+    setLoading(true)
+    setError(null)
+    try {
+      const result = await props.action(fields)
+      if (props.onResult)
+        props.onResult(result)
+      setResult(result)
+    } catch (error) {
+      console.error(error)
+      if (props.onError)
+        props.onError(error as Error)
+      setError(error as Error)
+      throw error
+    } finally {
+      setLoading(false)
+    }
+    return false
+  }, [props.action])
+
+  useEffect(() => {
+    if (props.autoTrigger)
+      callback(props.params as Fields)
+  }, [])
+
+
   return {
     loading,
     result,
     error,
     submit,
-    callback: props.action,
+    callback,
     params: props.params,
   }
 }
 
 export const ActionContext = createContext<ReturnType<typeof useActionProvider<any, any>> | undefined>(undefined)
 
-export function ActionProvider<Fields, Result>({children, ...params}: ActionProps<Fields, Result> & {
-  children: React.ReactNode | ( (props: ReturnType<typeof useActionProvider<Fields, Result>>) => React.ReactNode )
+export function ActionProvider<Fields, Result>({ children, ...params }: ActionProps<Fields, Result> & {
+  children: React.ReactNode | ((props: ReturnType<typeof useActionProvider<Fields, Result>>) => React.ReactNode)
 }) {
   const context = useActionProvider<Fields, Result>(params)
   return (

package/packages/react-interface.tsx

@@ -65,22 +65,28 @@ export function useTableProvider<TSchema extends TableSchema>({
     }
 }
 
-const TableContext = createContext<ReturnType<typeof useTableProvider<any>> | undefined>(undefined)
+const TableRegistryContext = createContext<Record<string, ReturnType<typeof useTableProvider<any>>> | undefined>(undefined)
 
 export function TableProvider<TSchema extends TableSchema>({ children, ...props }: React.PropsWithChildren<TableProviderProps<TSchema>>) {
 
     const context = useTableProvider(props)
+    const registry = useContext(TableRegistryContext) ?? {}
+
+    const newRegistry = useMemo(() => {
+        return { ...registry, [props.table]: context }
+    }, [registry, props.table, context])
 
     return (
-        <TableContext.Provider value={context}>
+        <TableRegistryContext.Provider value={newRegistry}>
             {children}
-        </TableContext.Provider>
+        </TableRegistryContext.Provider>
     )
 }
 
 export function TableConsumer<TSchema extends TableSchema>({ children }: { children: React.ReactNode | ((props: ReturnType<typeof useTableProvider<TSchema>>) => React.ReactNode) }) {
-    const context = useContext(TableContext)
-    if (!context) throw new Error('TableConsumer must be used within a TableProvider.')
+    const registry = useContext(TableRegistryContext)
+    if (!registry || Object.keys(registry).length === 0) throw new Error('TableConsumer must be used within a TableProvider.')
+    const context = Object.values(registry)[0]
     return (
         <>
             {typeof children === 'function' ? children(context) : children}
@@ -89,7 +95,9 @@ export function TableConsumer<TSchema extends TableSchema>({ children }: { child
 }
 
 export function useTable<TSchema extends TableSchema>(table: string, schema: TSchema) {
-    return useContext(TableContext) as ReturnType<typeof useTableProvider<TSchema>>
+    const registry = useContext(TableRegistryContext)
+    if (!registry || !registry[table]) throw new Error(`useTable("${table}") must be used within a TableProvider for that table.`)
+    return registry[table] as ReturnType<typeof useTableProvider<TSchema>>
 }
 
 export function CreateForm<TSchema extends TableSchema>({ table, schema, defaults, onSuccess, children }: {