asasvirtuais 2.2.0 → 2.2.2

package/package.json

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

package/packages/fetch-interface.tsx

@@ -1,21 +1,18 @@
 'use client'
 import { z } from 'zod'
 import { useMemo } from 'react'
-import { createContextFromHook } from './hooks'
 import type { TableInterface, TableSchema } from './interface'
+import { InterfaceProvider } from './interface-provider'
 
-export function useFetchInterfaceProvider<TSchema extends TableSchema>({
-  schema, baseUrl = '/api/v1', headers = {},
-}: {
-  schema: TSchema
-  baseUrl?: string
-  headers?: Record<string, string>
-}) {
-  return useMemo(() => fetchInterface({ schema, baseUrl, headers }), [schema, baseUrl])
+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 const [FetchInterfaceProvider, useFetchInterface] = createContextFromHook(useFetchInterfaceProvider<any>)
-
 export function fetchInterface<Schema extends TableSchema, Table extends string>({
   schema, defaultTable, baseUrl = '/api/v1', headers = {}
 }: {

package/packages/indexed-interface.tsx

@@ -2,19 +2,19 @@
 import Dexie from 'dexie'
 import { z } from 'zod'
 import { useMemo } from 'react'
-import { createContextFromHook } from './hooks'
-import type { DatabaseSchema, TableInterface } from './interface'
+import type { DatabaseSchema, TableInterface, TableSchema } from './interface'
+import { InterfaceProvider } from './interface-provider'
 
-export function useIndexedInterfaceProvider<Schema extends DatabaseSchema>({
-    dbName, schema,
-}: {
-    dbName: string
-    schema: Schema
-}) {
-    return useMemo(() => indexedInterface(dbName, schema), [dbName, schema])
-}
+export function IndexedInterfaceProvider<Schema extends DatabaseSchema>({ dbName, schema, children }: { dbName: string, schema: Schema, children: React.ReactNode }) {
 
-export const [IndexedInterfaceProvider, useIndexedInterface] = createContextFromHook(useIndexedInterfaceProvider<any>)
+    const memo = useMemo(() => indexedInterface(dbName, schema), [dbName, schema])
+
+    return (
+        <InterfaceProvider interface={memo}>
+            {children}
+        </InterfaceProvider>
+    )
+}
 
 /**
  * Creates a TableInterface adapter for IndexedDB using Dexie.js.
@@ -31,19 +31,6 @@ export function indexedInterface<Schema extends DatabaseSchema>(
 
     const db = new Dexie(dbName)
 
-    // Dynamically define the database schema for Dexie from the Zod schema.
-    // It marks 'id' as the primary key and indexes all other top-level readable fields.
-    const dexieSchema = Object.fromEntries(
-        Object.keys(schema).map(tableName => {
-            const fields = Object.keys(schema[tableName].readable.shape)
-            // 'id' is the primary key, the rest are indexed fields.
-            const indexedFields = fields.filter(f => f !== 'id').join(', ')
-            return [tableName, `id, ${indexedFields}`]
-        })
-    )
-
-    db.version(1).stores(dexieSchema)
-
     type GenericReadable = z.infer<Schema[keyof Schema]['readable']>
     type GenericWritable = z.infer<Schema[keyof Schema]['writable']>
 

package/packages/mem-interface.tsx

@@ -1,18 +1,17 @@
 'use client'
 import { useMemo } from 'react'
-import { createContextFromHook } from './hooks'
 import type { TableInterface, TableSchema } from './interface'
+import { InterfaceProvider } from './interface-provider'
 
-export function useMemInterfaceProvider<TSchema extends TableSchema>({
-    schema,
-}: {
-    schema: TSchema
-}) {
-    return useMemo(() => memInterface<TSchema>(), [schema])
+export function MemInterfaceProvider<TSchema extends TableSchema>({ children }: { children: React.ReactNode }) {
+    const memo = useMemo(() => memInterface<TSchema>(), [])
+    return (
+        <InterfaceProvider interface={memo}>
+            {children}
+        </InterfaceProvider>
+    )
 }
 
-export const [MemInterfaceProvider, useMemInterface] = createContextFromHook(useMemInterfaceProvider<any>)
-
 export function memInterface<TSchema extends TableSchema>(): TableInterface<any, any> {
 
     const store: Record<string, Record<string, any>> = {}