@arcote.tech/arc-react 0.0.33 → 0.1.0

package/dist/form/field.d.ts

@@ -1,5 +1,4 @@
-import { type ArcObjectAny, type ArcObjectKeys, type ArcObjectValueByKey } from "@arcote.tech/arc";
-import type { ArcAbstractAny } from "@arcote.tech/arc/elements/abstract";
+import type { ArcElement } from "@arcote.tech/arc/elements/element";
 import React from "react";
 export type FormFieldContext = {
     errors: any;
@@ -7,18 +6,18 @@ export type FormFieldContext = {
 };
 export declare const FormFieldContext: React.Context<FormFieldContext | null>;
 export declare function useFormField(): FormFieldContext;
-type Translations<E extends ArcAbstractAny> = {
-    [K in keyof ReturnType<E["validate"]>]: (data: Exclude<ReturnType<E["validate"]>[K], undefined>) => string;
-};
-type FormFieldProps<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = {
-    name: K;
-    translations: Translations<ArcObjectValueByKey<T, K>>;
-    render: (field: FormFieldData<T>) => React.ReactNode;
+type Translations<E extends ArcElement> = {
+    [K in keyof Exclude<ReturnType<E["validate"]>, false>]: (data: Exclude<Exclude<ReturnType<E["validate"]>, false>[K], undefined | false>) => string;
+} | ((data: any) => string) | string;
+type FormFieldProps<E extends ArcElement> = {
+    translations: Translations<E>;
+    render: (field: FormFieldData<E>) => React.ReactNode;
 };
 export type FormFieldData<T> = {
     onChange: (value: any) => void;
     value: any;
+    name: string;
 };
-export declare function FormField<T extends ArcObjectAny, K extends ArcObjectKeys<T>>({ name, translations, render, }: FormFieldProps<T, K>): import("react/jsx-dev-runtime").JSX.Element;
+export declare function FormField<E extends ArcElement>(name: string): ({ translations, render }: FormFieldProps<E>) => import("react/jsx-dev-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=field.d.ts.map

package/dist/form/form.d.ts

@@ -1,4 +1,4 @@
-import { type ArcObjectAny, type ArcObjectKeys } from "@arcote.tech/arc";
+import { type ArcObjectAny, type ArcObjectKeys, type ArcObjectValueByKey } from "@arcote.tech/arc";
 import React from "react";
 import { FormField } from "./field";
 export type FormContextValue<T extends ArcObjectAny> = {
@@ -12,7 +12,7 @@ export type FormContextValue<T extends ArcObjectAny> = {
 export declare const FormContext: React.Context<FormContextValue<any> | null>;
 export declare function Form<T extends ArcObjectAny>({ render, schema, onSubmit, }: {
     render: (props: {
-        FormField: typeof FormField<T, ArcObjectKeys<T>>;
+        [K in ArcObjectKeys<T> as Capitalize<`${K}`>]: ReturnType<typeof FormField<ArcObjectValueByKey<T, K>>>;
     }) => React.ReactNode;
     schema: T;
     onSubmit: (values: Record<ArcObjectKeys<T>, any>) => void | Promise<void>;

package/dist/form/index.d.ts

@@ -2,5 +2,4 @@ export * from "./field";
 export * from "./form";
 export * from "./legacy_form_resolver";
 export * from "./message";
-export * from "./test";
 //# sourceMappingURL=index.d.ts.map

package/dist/form/message.d.ts

@@ -1,3 +1,6 @@
-import React from "react";
-export declare const FormMessage: React.ForwardRefExoticComponent<React.RefAttributes<HTMLDivElement>>;
+import { type HTMLAttributes } from "react";
+export declare function FormMessage({ ...props }: HTMLAttributes<HTMLSpanElement>): import("react/jsx-dev-runtime").JSX.Element | null;
+export declare namespace FormMessage {
+    var displayName: string;
+}
 //# sourceMappingURL=message.d.ts.map

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./form/";
-export * from "./idb.ts";
 export * from "./reactModel.tsx";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,7 +22,6 @@ function Form({
   const [dirty, setDirty] = useState(new Set);
   const [isSubmitted, setIsSubmitted] = useState(false);
   const validate = useCallback(() => {
-    console.log("validate", values, schema);
     const errors2 = schema.validate(values);
     setErrors(errors2);
     return Object.values(errors2).some((result) => result);
@@ -42,12 +41,17 @@ function Form({
   const handleSubmit = useCallback(async (e) => {
     e.preventDefault();
     setIsSubmitted(true);
-    validate();
-    if (!hasErrors) {
+    const hasErrors2 = validate();
+    if (!hasErrors2) {
       await onSubmit(values);
     }
   }, [schema, values, onSubmit, hasErrors]);
-  const FF = useCallback(FormField, []);
+  const Fields = useMemo(() => {
+    return Object.fromEntries(schema.entries().map(([key, value]) => [
+      key.charAt(0).toUpperCase() + key.slice(1),
+      FormField(key)
+    ]));
+  }, [schema]);
   const contextValue = useMemo(() => ({
     values,
     errors,
@@ -60,7 +64,7 @@ function Form({
     value: contextValue,
     children: /* @__PURE__ */ jsx("form", {
       onSubmit: handleSubmit,
-      children: render({ FormField: FF })
+      children: render(Fields)
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -75,45 +79,52 @@ function useFormField() {
     throw new Error("useFormField must be used within a FormFieldProvider");
   return context;
 }
-function FormField({
-  name,
-  translations,
-  render
-}) {
-  const form = useContext(FormContext);
-  if (!form)
-    throw new Error("FormField must be used within a Form");
-  const { values, errors, dirty, isSubmitted, setFieldValue, setFieldDirty } = form;
-  const fieldErrors = errors[name] || {};
-  const value = values[name] || "";
-  const isDirty = dirty.has(name);
-  const handleChange = useCallback2((value2) => {
-    if (typeof value2 === "string") {
-      setFieldValue(name, value2);
-    } else if (value2?.target?.value !== undefined) {
-      setFieldValue(name, value2.target.value);
-    }
-    if (!isDirty) {
-      setFieldDirty(name);
-    }
-  }, [name, isDirty, setFieldValue, setFieldDirty]);
-  const errorMessages = Object.entries(fieldErrors).map(([key, value2]) => {
-    if (!value2)
-      return;
-    const translation = translations[key];
-    return translation?.(value2);
-  }).filter(Boolean);
-  const contextValue = useMemo2(() => ({
-    errors: isSubmitted ? fieldErrors : {},
-    messages: errorMessages
-  }), [fieldErrors, isSubmitted, errorMessages]);
-  return /* @__PURE__ */ jsx2(FormFieldContext.Provider, {
-    value: contextValue,
-    children: render({
-      onChange: handleChange,
-      value
-    })
-  }, undefined, false, undefined, this);
+function FormField(name) {
+  return ({ translations, render }) => {
+    const form = useContext(FormContext);
+    if (!form)
+      throw new Error("FormField must be used within a Form");
+    const { values, errors, dirty, isSubmitted, setFieldValue, setFieldDirty } = form;
+    const schemaErrors = errors?.["schema"] || {};
+    const fieldErrors = schemaErrors[name] || false;
+    const value = values[name] || "";
+    const isDirty = dirty.has(name);
+    const handleChange = useCallback2((value2) => {
+      if (typeof value2 === "string") {
+        setFieldValue(name, value2);
+      } else if (value2?.target?.value !== undefined) {
+        setFieldValue(name, value2.target.value);
+      }
+      if (!isDirty) {
+        setFieldDirty(name);
+      }
+    }, [name, isDirty, setFieldValue, setFieldDirty]);
+    const errorMessages = fieldErrors ? Object.entries(fieldErrors).map(([key, value2]) => {
+      if (!value2)
+        return;
+      if (!translations)
+        return;
+      const translation = translations[key] || translations;
+      if (typeof translation === "function") {
+        return translation(value2);
+      }
+      if (typeof translation === "string") {
+        return translation;
+      }
+    }).filter(Boolean) : [];
+    const contextValue = useMemo2(() => ({
+      errors: isSubmitted ? fieldErrors : false,
+      messages: errorMessages
+    }), [fieldErrors, isSubmitted, errorMessages]);
+    return /* @__PURE__ */ jsx2(FormFieldContext.Provider, {
+      value: contextValue,
+      children: render({
+        onChange: handleChange,
+        name: name.toString(),
+        value
+      })
+    }, undefined, false, undefined, this);
+  };
 }
 // form/legacy_form_resolver.ts
 function formResolver(schema) {
@@ -125,214 +136,22 @@ function formResolver(schema) {
   };
 }
 // form/message.tsx
-import React3 from "react";
 import { jsx as jsx3 } from "react/jsx-runtime";
-var FormMessage = React3.forwardRef(({}, ref) => {
+function FormMessage({ ...props }) {
   const { messages } = useFormField();
   if (messages.length === 0)
     return null;
-  return /* @__PURE__ */ jsx3("div", {
-    className: "text-destructive",
-    ref,
+  return /* @__PURE__ */ jsx3("span", {
+    ...props,
     children: messages[0]
   }, undefined, false, undefined, this);
-});
-FormMessage.displayName = "FormMessage";
-// form/test.tsx
-import { object, string } from "@arcote.tech/arc";
-import { jsx as jsx4, Fragment } from "react/jsx-runtime";
-function Test() {
-  const schema = object({
-    username: string().minLength(3).maxLength(10)
-  });
-  const handleSubmit = async (values) => {
-    console.log("Form submitted:", values);
-  };
-  return /* @__PURE__ */ jsx4(Form, {
-    schema,
-    onSubmit: handleSubmit,
-    render: ({ FormField: FormField2 }) => /* @__PURE__ */ jsx4("div", {
-      children: [
-        /* @__PURE__ */ jsx4(FormField2, {
-          name: "username",
-          translations: {
-            minLength: ({ minLength }) => `Username must be at least ${minLength} characters long`,
-            maxLength: ({ maxLength }) => `Username must be at most ${maxLength} characters long`
-          },
-          render: (field) => /* @__PURE__ */ jsx4(Fragment, {
-            children: [
-              /* @__PURE__ */ jsx4("input", {
-                className: "border border-gray-300 rounded-md p-2",
-                ...field
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx4(FormMessage, {}, undefined, false, undefined, this)
-            ]
-          }, undefined, true, undefined, this)
-        }, undefined, false, undefined, this),
-        /* @__PURE__ */ jsx4("button", {
-          type: "submit",
-          children: "Submit"
-        }, undefined, false, undefined, this)
-      ]
-    }, undefined, true, undefined, this)
-  }, undefined, false, undefined, this);
-}
-// idb.ts
-import {
-  ArcCollection,
-  ArcIndexedCollection
-} from "@arcote.tech/arc";
-var idbAdapterFactory = (name, version) => (context) => new Promise((resolve, reject) => {
-  const dbRequest = indexedDB.open(name, version);
-  dbRequest.addEventListener("error", (err) => {
-    reject(err);
-  });
-  dbRequest.addEventListener("success", (ev) => {
-    resolve(new IDBAdapter(ev.target.result));
-  });
-  dbRequest.addEventListener("upgradeneeded", (ev) => {
-    const db = ev.target.result;
-    context.elements.filter((element) => element instanceof ArcIndexedCollection || element instanceof ArcCollection).forEach((collection) => {
-      const name2 = collection.name;
-      if (db.objectStoreNames.contains(name2)) {
-        db.deleteObjectStore(collection.name);
-      }
-      const objectStore = db.createObjectStore(collection.name, {
-        keyPath: "_id"
-      });
-      if (collection instanceof ArcIndexedCollection) {
-        Object.entries(collection.indexes).forEach(([name3, keyPath]) => {
-          objectStore.createIndex(name3, keyPath, {
-            unique: false
-          });
-        });
-      }
-    });
-    if (db.objectStoreNames.contains("state")) {
-      db.deleteObjectStore("state");
-    }
-    db.createObjectStore("state", {
-      keyPath: "_id"
-    });
-  });
-});
-
-class IDBReadTransaction {
-  transaction;
-  constructor(transaction) {
-    this.transaction = transaction;
-  }
-  async findById(store, id) {
-    return new Promise((resolve) => {
-      if (!id) {
-        resolve(undefined);
-        return;
-      }
-      const result = this.transaction.objectStore(store).get(id);
-      result.onsuccess = (e) => {
-        resolve(e.target.result);
-      };
-    });
-  }
-  async findByIndex(store, index, data) {
-    return new Promise((resolve) => {
-      const idbIndex = this.transaction.objectStore(store).index(index);
-      const keyPath = idbIndex.keyPath;
-      let keyRange;
-      const getKey = (obj) => {
-        if (!obj)
-          return;
-        const key = keyPath.map((key2) => obj[key2]);
-        if (key.some((value) => value === undefined))
-          return;
-        return key;
-      };
-      const simpleKey = getKey(data);
-      if (!simpleKey) {
-        const lower = "$gt" in data ? getKey(data.$gt) : getKey(data.$gte);
-        const upper = "$lt" in data ? getKey(data.$lt) : getKey(data.$lte);
-        const lowerOpen = "$gt" in data;
-        const upperOpen = "$lt" in data;
-        if (lower !== undefined && upper !== undefined) {
-          keyRange = IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen);
-        } else if (lower !== undefined) {
-          keyRange = IDBKeyRange.lowerBound(lower, lowerOpen);
-        } else {
-          keyRange = IDBKeyRange.upperBound(upper, upperOpen);
-        }
-      } else {
-        keyRange = IDBKeyRange.only(simpleKey);
-      }
-      const result = idbIndex.getAll(keyRange);
-      result.onsuccess = (e) => {
-        resolve(e.target.result);
-      };
-    });
-  }
-  async findAll(store) {
-    return new Promise((resolve) => {
-      const result = this.transaction.objectStore(store).getAll();
-      result.onsuccess = (e) => {
-        resolve(e.target.result);
-      };
-    });
-  }
-}
-
-class IDBReadWriteTransaction extends IDBReadTransaction {
-  async set(store, data) {
-    return new Promise((resolve, reject) => {
-      const result = this.transaction.objectStore(store).put(data);
-      result.onsuccess = (e) => {
-        resolve();
-      };
-      result.onerror = (e) => {
-        reject(e);
-      };
-    });
-  }
-  async remove(store, id) {
-    return new Promise((resolve, reject) => {
-      const result = this.transaction.objectStore(store).delete(id);
-      result.onsuccess = (e) => {
-        resolve();
-      };
-      result.onerror = (e) => {
-        reject(e);
-      };
-    });
-  }
-  async commit() {
-    return new Promise((resolve) => {
-      this.transaction.oncomplete = () => {
-        resolve();
-      };
-      this.transaction.commit();
-    });
-  }
-}
-
-class IDBAdapter {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  readWriteTransaction(stores) {
-    if (!stores)
-      stores = Array.from(this.db.objectStoreNames);
-    const transaction = this.db.transaction(stores, "readwrite");
-    return new IDBReadWriteTransaction(transaction);
-  }
-  readTransaction(stores) {
-    if (!stores)
-      stores = Array.from(this.db.objectStoreNames);
-    const transaction = this.db.transaction(stores, "readonly");
-    return new IDBReadTransaction(transaction);
-  }
 }
+FormMessage.displayName = "FormMessage";
 // reactModel.tsx
 import {
   MasterDataStorage,
+  Model,
+  RemoteModelClient,
   rtcClientFactory
 } from "@arcote.tech/arc";
 import {
@@ -343,126 +162,133 @@ import {
   useRef,
   useState as useState2
 } from "react";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var reactModel = (arcContext, databaseName) => {
+
+// sqliteWasmAdapter.ts
+import {
+  createSQLiteAdapterFactory
+} from "@arcote.tech/arc";
+var sqliteWasmAdapterFactory = (db) => {
+  return async (context) => {
+    return createSQLiteAdapterFactory(db)(context);
+  };
+};
+
+// reactModel.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var reactModel = (arcContext, options) => {
   const LiveModelContext = createContext3(null);
   const LocalModelContext = createContext3(null);
-  let modelMasterDataStorage = null;
+  let masterModel = null;
   return [
     function LiveModelProvider(props) {
-      const dataStorage = useMemo3(() => {
+      const model = useMemo3(() => {
         if (typeof window === "undefined")
           return null;
-        const dbAdapterPromise = idbAdapterFactory(databaseName, arcContext.version)(arcContext);
-        const dataStorage2 = new MasterDataStorage(dbAdapterPromise, rtcClientFactory(props.token), arcContext);
-        modelMasterDataStorage = dataStorage2;
-        return dataStorage2;
-      }, [arcContext, databaseName, arcContext.version]);
+        if (masterModel)
+          return masterModel;
+        if ("remoteUrl" in options) {
+          const model2 = new RemoteModelClient(arcContext, options.remoteUrl, props.client, props.catchErrorCallback);
+          masterModel = model2;
+          return model2;
+        } else {
+          const dbAdapterPromise = sqliteWasmAdapterFactory(options.sqliteAdapter)(arcContext);
+          const dataStorage = new MasterDataStorage(dbAdapterPromise, rtcClientFactory(props.token), arcContext);
+          const model2 = new Model(arcContext, dataStorage, props.client, props.catchErrorCallback);
+          masterModel = model2;
+          return model2;
+        }
+      }, [arcContext, options, props.client]);
       const [syncProgress, setSyncProgress] = useState2([]);
       const [syncDone, setSyncDone] = useState2(false);
       useEffect2(() => {
-        if (typeof window === "undefined" || !dataStorage)
+        if (typeof window === "undefined" || !model)
           return;
         const sync = async () => {
-          await dataStorage.sync(({ store, size }) => {
+          if (!("dataStorage" in model))
+            return setSyncDone(true);
+          await model.dataStorage.sync(({ store, size }) => {
             setSyncProgress((prev) => [...prev, { store, size }]);
           });
           setSyncDone(true);
         };
         sync();
-      }, [dataStorage]);
-      if (!dataStorage || !syncDone)
-        return /* @__PURE__ */ jsx5(props.syncView, {
+      }, [model]);
+      if (!model || !syncDone)
+        return props.syncView ? /* @__PURE__ */ jsx4(props.syncView, {
           progress: syncProgress
-        }, undefined, false, undefined, this);
-      return /* @__PURE__ */ jsx5(LiveModelContext.Provider, {
-        value: {
-          dataStorage,
-          client: props.client,
-          catchErrorCallback: props.catchErrorCallback
-        },
+        }, undefined, false, undefined, this) : null;
+      return /* @__PURE__ */ jsx4(LiveModelContext.Provider, {
+        value: model,
         children: props.children
       }, undefined, false, undefined, this);
     },
     function LocalModelProvider({ children }) {
-      const parentContext = useContext2(LiveModelContext);
-      if (!parentContext) {
+      const parentModel = useContext2(LiveModelContext);
+      if (!parentModel || !(parentModel instanceof Model)) {
         throw new Error("LocalModelProvider must be used within a LiveModelProvider");
       }
-      const [localContext] = useState2(() => ({
-        dataStorage: parentContext.dataStorage.fork()
-      }));
-      return /* @__PURE__ */ jsx5(LocalModelContext.Provider, {
-        value: {
-          dataStorage: localContext.dataStorage,
-          client: parentContext.client,
-          catchErrorCallback: parentContext.catchErrorCallback
-        },
+      const [localModel] = useState2(() => parentModel.fork());
+      return /* @__PURE__ */ jsx4(LocalModelContext.Provider, {
+        value: localModel,
         children
       }, undefined, false, undefined, this);
     },
     function useQuery(queryBuilderFn, dependencies = []) {
-      const context = useContext2(LocalModelContext) || useContext2(LiveModelContext);
-      if (!context) {
+      const model = useContext2(LocalModelContext) || useContext2(LiveModelContext);
+      if (!model) {
         throw new Error("useQuery must be used within a ModelProvider");
       }
       const [result, setResult] = useState2(null);
       const [loading, setLoading] = useState2(true);
-      const queryRef = useRef(null);
+      const unsubscribeRef = useRef(null);
       useEffect2(() => {
-        if (queryRef.current)
-          queryRef.current.unsubscribe();
-        const queryBuilder = arcContext.queryBuilder();
-        const query = queryBuilderFn(queryBuilder).toQuery();
-        queryRef.current = query;
-        const runQuery = async () => {
-          const result2 = await query.run(context.dataStorage, (newResult) => {
-            setResult(newResult);
-            setLoading(false);
-          });
-          setResult(result2);
+        if (unsubscribeRef.current) {
+          unsubscribeRef.current();
+        }
+        const { unsubscribe, result: result2 } = model.subscribe(queryBuilderFn, (newResult) => {
+          setResult(newResult);
           setLoading(false);
-        };
-        runQuery();
+        });
+        unsubscribeRef.current = unsubscribe;
+        result2.then(() => {
+          setLoading(false);
+        });
         return () => {
-          queryRef.current?.unsubscribe();
-          queryRef.current = null;
+          if (unsubscribeRef.current) {
+            unsubscribeRef.current();
+            unsubscribeRef.current = null;
+          }
         };
-      }, [context, ...dependencies]);
+      }, [model, ...dependencies]);
       return [result, loading];
     },
     function useCommands() {
-      const context = useContext2(LocalModelContext) || useContext2(LiveModelContext);
-      if (!context) {
-        throw new Error("useQuery must be used within a ModelProvider");
+      const model = useContext2(LocalModelContext) || useContext2(LiveModelContext);
+      if (!model) {
+        throw new Error("useCommands must be used within a ModelProvider");
       }
-      return arcContext.commandsClient(context.client, context.dataStorage, context.catchErrorCallback);
+      return model.commands();
     },
-    async function query(queryBuilderFn, datastorage) {
-      if (!datastorage)
-        datastorage = modelMasterDataStorage;
-      const queryBuilder = arcContext.queryBuilder();
-      const query = queryBuilderFn(queryBuilder).toQuery();
-      if (!datastorage)
-        throw new Error("dataStorage not found");
-      const result = await query.run(datastorage);
-      return result;
+    async function query(queryBuilderFn, model) {
+      if (!model)
+        model = masterModel;
+      if (!model)
+        throw new Error("Model not found");
+      return model.query(queryBuilderFn);
     },
-    function useLocalDataStorage() {
-      const context = useContext2(LocalModelContext);
-      if (!context) {
+    function useLocalModel() {
+      const model = useContext2(LocalModelContext);
+      if (!model) {
         return null;
       }
-      return context.dataStorage;
+      return model;
     }
   ];
 };
 export {
   useFormField,
   reactModel,
-  idbAdapterFactory,
   formResolver,
-  Test,
   FormMessage,
   FormFieldContext,
   FormField,
@@ -470,4 +296,4 @@ export {
   Form
 };
 
-//# debugId=1DDD66A12E066C4464756E2164756E21
+//# debugId=F5FEB20267C5EE2264756E2164756E21

package/dist/reactModel.d.ts

@@ -1,16 +1,21 @@
-import { ForkedDataStorage, type ArcContextAny, type CommandsClient, type DataStorage, type QueryBuilderFunctionResult, type QueryFactoryFunction } from "@arcote.tech/arc";
-export declare const reactModel: <C extends ArcContextAny>(arcContext: C, databaseName: string) => readonly [(props: {
+import { ForkedModel, type ArcContextAny, type IArcQueryBuilder, type ModelBase, type QueryBuilderFunctionResult, type QueryFactoryFunction, type UnaryFunction } from "@arcote.tech/arc";
+import type { SQLiteDatabase } from "@arcote.tech/arc";
+export declare const reactModel: <C extends ArcContextAny>(arcContext: C, options: {
+    sqliteAdapter: SQLiteDatabase;
+} | {
+    remoteUrl: string;
+}) => readonly [(props: {
     children: React.ReactNode;
     client: string;
     token: string;
-    syncView: React.ComponentType<{
+    syncView?: React.ComponentType<{
         progress: {
             store: string;
             size: number;
         }[];
     }>;
     catchErrorCallback: (error: any) => void;
-}) => import("react/jsx-dev-runtime").JSX.Element, ({ children }: {
+}) => import("react/jsx-dev-runtime").JSX.Element | null, ({ children }: {
     children: React.ReactNode;
-}) => import("react/jsx-dev-runtime").JSX.Element, <QueryBuilderFn extends QueryFactoryFunction<C>>(queryBuilderFn: QueryBuilderFn, dependencies?: any[]) => [QueryBuilderFunctionResult<QueryBuilderFn>, boolean], () => CommandsClient<C["commands"]>, <QueryBuilderFn extends QueryFactoryFunction<C>>(queryBuilderFn: QueryBuilderFn, datastorage?: DataStorage | null) => Promise<QueryBuilderFunctionResult<QueryBuilderFn>>, () => ForkedDataStorage | null];
+}) => import("react/jsx-dev-runtime").JSX.Element, <Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, dependencies?: any[]) => [ReturnType<Q["toQuery"]>["lastResult"], boolean], () => ReturnType<C["commandsClient"]>, <QueryBuilderFn extends QueryFactoryFunction<C>>(queryBuilderFn: QueryBuilderFn, model?: ModelBase<C> | null) => Promise<QueryBuilderFunctionResult<QueryBuilderFn>>, () => ForkedModel<C> | null];
 //# sourceMappingURL=reactModel.d.ts.map

package/dist/sqliteWasmAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { SQLiteDatabase } from "@arcote.tech/arc";
+import { type DBAdapterFactory } from "@arcote.tech/arc";
+export declare const sqliteWasmAdapterFactory: (db: SQLiteDatabase) => DBAdapterFactory;
+//# sourceMappingURL=sqliteWasmAdapter.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.33",
+  "version": "0.1.0",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "React client for the Arc framework, providing utilities for querying data and executing commands, enhancing the development of reactive and efficient user interfaces.",

package/dist/form/test.d.ts

@@ -1,2 +0,0 @@
-export declare function Test(): import("react/jsx-dev-runtime").JSX.Element;
-//# sourceMappingURL=test.d.ts.map

package/dist/idb.d.ts

@@ -1,3 +0,0 @@
-import { type DBAdapterFactory } from "@arcote.tech/arc";
-export declare const idbAdapterFactory: (name: string, version: number) => DBAdapterFactory;
-//# sourceMappingURL=idb.d.ts.map