asasvirtuais 2.2.9 → 2.3.1

package/package.json

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

package/packages/{fetch-interface.tsx → fetch-interface.ts}

@@ -1,17 +1,5 @@
-'use client'
 import { z } from 'zod'
-import { useMemo } from 'react'
 import type { TableInterface, TableSchema } from './interface'
-import { InterfaceProvider } from './interface-provider'
-
-export function FetchInterfaceProvider<Schema extends TableSchema>({ schema, defaultTable, baseUrl, headers, children }: { schema: Schema, defaultTable?: string, baseUrl?: string, headers?: Record<string, string>, children: React.ReactNode }) {
-    const memo = useMemo(() => fetchInterface({ schema, defaultTable, baseUrl, headers }), [schema, defaultTable, baseUrl, headers])
-    return (
-        <InterfaceProvider interface={memo}>
-          {children}
-        </InterfaceProvider>
-    )
-}
 
 export function fetchInterface<Schema extends TableSchema, Table extends string>({
   schema, defaultTable, baseUrl = '/api/v1', headers = {}

package/packages/fetch-provider.tsx

@@ -0,0 +1,14 @@
+'use client'
+import { useMemo } from 'react'
+import { TableSchema } from './interface'
+import { fetchInterface } from './fetch-interface'
+import { InterfaceProvider } from './interface-provider'
+
+export function FetchInterfaceProvider<Schema extends TableSchema>({ schema, defaultTable, baseUrl, headers, children }: { schema: Schema, defaultTable?: string, baseUrl?: string, headers?: Record<string, string>, children: React.ReactNode }) {
+    const memo = useMemo(() => fetchInterface({ schema, defaultTable, baseUrl, headers }), [schema, defaultTable, baseUrl, headers])
+    return (
+        <InterfaceProvider {...memo}>
+          {children}
+        </InterfaceProvider>
+    )
+}

package/packages/interface-provider.tsx

@@ -2,9 +2,7 @@
 import { createContextFromHook } from './hooks'
 import type { TableInterface } from './interface'
 
-function useInterfaceProvider({ interface: tableInterface }: {
-    interface: TableInterface<any, any>
-}) {
+function useInterfaceProvider(tableInterface: TableInterface<any, any>) {
     return tableInterface
 }
 

package/packages/mem-interface.tsx

@@ -1,16 +1,5 @@
 'use client'
-import { useMemo } from 'react'
 import type { TableInterface, TableSchema } from './interface'
-import { InterfaceProvider } from './interface-provider'
-
-export function MemInterfaceProvider<TSchema extends TableSchema>({ children }: { children: React.ReactNode }) {
-    const memo = useMemo(() => memInterface<TSchema>(), [])
-    return (
-        <InterfaceProvider interface={memo}>
-            {children}
-        </InterfaceProvider>
-    )
-}
 
 export function memInterface<TSchema extends TableSchema>(): TableInterface<any, any> {
 

package/packages/mem-provider.tsx

@@ -0,0 +1,13 @@
+import { useMemo } from "react";
+import type { TableSchema } from "./interface";
+import { InterfaceProvider } from "./interface-provider";
+import { memInterface } from "./mem-interface";
+
+export function MemInterfaceProvider<TSchema extends TableSchema>({ children }: { children: React.ReactNode} ) {
+    const memo = useMemo(() => memInterface<TSchema>(), [])
+    return (
+        <InterfaceProvider {...memo}>
+            {children}
+        </InterfaceProvider>
+    )
+}

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 }: {