@mgarlik/datastore 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,14 +1,19 @@
-// src/DataStoreProvider.tsx
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import {
+  systemLog
+} from "./chunk-7XDRKNJQ.js";
 
-// src/log.ts
-function systemLog(..._args) {
-}
-function systemLogError(...args) {
-  if (typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(...args);
-  }
-}
+// src/DataStoreProvider.tsx
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
 
 // src/handleSocketMessage.ts
 var handleSocketMessage = (model, msg, dataProvider) => {
@@ -40,9 +45,6 @@ var handleSocketMessage = (model, msg, dataProvider) => {
 // src/handleData.ts
 import axios from "axios";
 
-// src/utils.ts
-import * as Crypto from "expo-crypto";
-
 // src/dotPath.ts
 function propToArray(prop) {
   return prop.split(".").reduce((ret, el, index, list) => {
@@ -87,6 +89,13 @@ function getValueByDotPath(obj, prop, value) {
 
 // src/utils.ts
 import dayjs from "dayjs";
+function randomUuidSegment(template) {
+  return template.replace(/[xy]/g, (char) => {
+    const random = Math.floor(Math.random() * 16);
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -549,7 +558,13 @@ var dataStoreFilterObject = (obj, filter) => {
   return result;
 };
 function uuid() {
-  return Crypto.randomUUID();
+  return [
+    randomUuidSegment("xxxxxxxx"),
+    randomUuidSegment("xxxx"),
+    "4" + randomUuidSegment("xxx"),
+    randomUuidSegment("yxxx"),
+    randomUuidSegment("xxxxxxxxxxxx")
+  ].join("-");
 }
 function isUuid(val) {
   if (typeof val !== "string") return false;
@@ -562,7 +577,7 @@ var saveData = async ({
   providerId,
   newData,
   dateUpdate,
-  SQLite: SQLite3
+  SQLite
 }) => {
   console.time(`[SQL] saveData ${providerId}`);
   const batchSize = 8e3;
@@ -577,8 +592,7 @@ var saveData = async ({
       }
     }
     const placeholdersArray = Array.from({ length: Math.ceil(values.length / 4) }, () => placeholders).join(",");
-    if (placeholdersArray.length < 10) console.log("DATA TO UPDATE", JSON.stringify(values, null, 2));
-    const row = await SQLite3.query(`INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES ${placeholdersArray}`, values);
+    const row = await SQLite.query(`INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES ${placeholdersArray}`, values);
     systemLog("axios", "saveData result: ", JSON.stringify(row));
   }
   console.timeEnd(`[SQL] saveData ${providerId}`);
@@ -600,7 +614,7 @@ var buildUri = ({
   }
   return dataSource.uri || `${dataSource.model || ""}/`;
 };
-var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, changeTime }) => {
+var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime }) => {
   if (dataSource) systemLog("axios", "GET Data Source: ", buildUri({ dataSource, method: "read" }));
   else systemLog("axios", "No DataSource for ", id);
   let persistedData = [];
@@ -617,12 +631,24 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, ch
     } else {
       if (changeTime) {
         params.changeTime = changeTime;
-      } else if (isPersisting && SQLite3) {
+      } else if (isPersisting && SQLite) {
         console.time("Persisted Data");
-        const qDatum = await SQLite3.read(`SELECT * FROM documents WHERE model = '${id}' ORDER BY lastUpdate DESC`);
+        const qDatum = await SQLite.read(`SELECT * FROM documents WHERE model = '${id}' ORDER BY lastUpdate DESC`);
         systemLog("axios", "SQLite.read Posledni datum update: ", qDatum[0]?.lastUpdate);
         if (qDatum[0]?.lastUpdate) params.changeTime = qDatum[0].lastUpdate;
-        persistedData = qDatum.map((item) => ({ id: item.id, ...JSON.parse(item.data) }));
+        persistedData = qDatum.map((item) => {
+          try {
+            const parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
+            if (!parsedData || typeof parsedData !== "object" || Array.isArray(parsedData)) {
+              systemLog("axios", "SQLite.read Preskakuji neplatny dokument:", item.id);
+              return null;
+            }
+            return { id: item.id, ...parsedData };
+          } catch (error) {
+            console.error("[datastore] Nepodarilo se zpracovat SQL data pro dokument", item.id, error);
+            return null;
+          }
+        }).filter((item) => item !== null);
         console.timeEnd("Persisted Data");
       }
       if (dataSource) {
@@ -670,8 +696,8 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, ch
           JSON.stringify(newData).length,
           "Bytes"
         );
-        if (isPersisting && SQLite3) {
-          await saveData({ providerId: id, newData, SQLite: SQLite3, dateUpdate: axiosResponse.data.queryAt || (/* @__PURE__ */ new Date()).toISOString() });
+        if (isPersisting && SQLite) {
+          await saveData({ providerId: id, newData, SQLite, dateUpdate: axiosResponse.data.queryAt || (/* @__PURE__ */ new Date()).toISOString() });
         }
       }
     }
@@ -736,7 +762,6 @@ var deleteData = async ({ dataSource, data }) => {
 // src/DataStoreProvider.tsx
 import { io as ioSockets } from "socket.io-client";
 import axios2 from "axios";
-import { getLocales } from "expo-localization";
 
 // src/templates.ts
 var _renderMyTemplate = (templateString, data) => {
@@ -767,162 +792,7 @@ function renderJSONTemplate(val, data) {
 
 // src/DataStoreProvider.tsx
 import isEqual from "lodash/isEqual.js";
-
-// src/database.ts
-import * as SQL from "expo-sqlite";
-var SQLite = class {
-  constructor(name) {
-    this.db = null;
-    this.dbName = name || "modelaz.db";
-    this.initDB();
-  }
-  async initDB() {
-    if (!this.db) {
-      try {
-        systemLog("sql", "[initDB]");
-        this.db = await SQL.openDatabaseAsync(this.dbName);
-        await this.createTables({
-          documents: "id TEXT PRIMARY KEY, data TEXT, model TEXT, lastUpdate TEXT"
-          // logs: "time TEXT PRIMARY KEY, module TEXT, message TEXT",
-        });
-      } catch (e) {
-        console.log("INITDB ERROR", e);
-        throw e;
-      }
-    }
-  }
-  async getDb() {
-    if (!this.db) {
-      await this.initDB();
-    }
-    if (!this.db) {
-      throw new Error("Database is not initialized");
-    }
-    return this.db;
-  }
-  async createTable(table, tableSchema) {
-    try {
-      systemLog("sql", "[createTable]", table);
-      const db = await this.getDb();
-      const result = await db.runAsync(`CREATE TABLE IF NOT EXISTS '${table}' (${tableSchema})`);
-      systemLog("sql", "[createTable] result: ", JSON.stringify(result));
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[createTable]", e);
-      throw e;
-    }
-  }
-  async createTables(tables) {
-    try {
-      systemLog("sql", "[createTables]", tables);
-      const query = Object.entries(tables).reduce((acc, [table, schema]) => {
-        return acc + `CREATE TABLE IF NOT EXISTS '${table}' (${schema});`;
-      }, "");
-      const db = await this.getDb();
-      const result = await db.runAsync(query);
-      systemLog("sql", "[createTables] result: ", JSON.stringify(result));
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[createTable]", e);
-      throw e;
-    }
-  }
-  /**
-   * Smazani starych logu
-   */
-  async deleteLogs() {
-    systemLog("sql", "[query] delete old Logs", this.db);
-    try {
-      const db = await this.getDb();
-      await db.runAsync(`DELETE FROM logs WHERE strftime('%s', 'now') - strftime('%s', time) > 3600`);
-    } catch (error) {
-      throw error;
-    }
-  }
-  async read(query, args) {
-    try {
-      systemLog("sql", "[read]", query);
-      const db = await this.getDb();
-      const result = args === void 0 ? await db.getAllAsync(query) : await db.getAllAsync(query, args);
-      systemLog("sql", "[read] result ", result.length);
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[read]", e);
-      throw e;
-    }
-  }
-  async query(query, args) {
-    try {
-      systemLog("sql", "[query]->", query);
-      const db = await this.getDb();
-      const result = args === void 0 ? await db.getAllAsync(query) : await db.getAllAsync(query, args);
-      systemLog("sql", result);
-      return result;
-    } catch (error) {
-      console.error("INSERT ERROR", error);
-      systemLogError("sql", error);
-      throw error;
-    }
-  }
-  async dropTable(table) {
-    try {
-      systemLog("sql", "dropTable", table);
-      console.time("[SQL] dropTable");
-      const db = await this.getDb();
-      const result = await db.runAsync(`DROP TABLE ${table}`);
-      console.timeEnd("[SQL] dropTable");
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async emptyTable(table) {
-    try {
-      systemLog("sql", `[emptyTable]`, table);
-      const db = await this.getDb();
-      const result = await db.runAsync(`DELETE FROM '${table}'`);
-      systemLog("sql", "[emptyTable] result", result);
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getTables() {
-    systemLog("sql", "Jdu zkusit nacist tabulky z ", JSON.stringify(this.dbName));
-    try {
-      const db = await this.getDb();
-      const result = await db.getAllAsync('SELECT name FROM sqlite_master WHERE type="table"');
-      systemLog("sql", "DB Result:", result);
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async resetDatabase() {
-    try {
-      systemLog("sql", "Reset database", this.dbName);
-      console.time("DELETING");
-      systemLog("sql", "Closing");
-      const db = await this.getDb();
-      await db.closeAsync();
-      systemLog("sql", "Deleting");
-      await SQL.deleteDatabaseAsync(this.dbName);
-      console.timeEnd("DELETING");
-      console.time("INIT");
-      this.db = null;
-      systemLog("sql", "Zacinam inicializovat databazi databaze");
-      await this.initDB();
-      systemLog("sql", "Inicializovana databaze");
-      console.timeEnd("INIT");
-    } catch (e) {
-      systemLogError("sql", "[resetDatabase]", e);
-    }
-  }
-};
-
-// src/DataStoreProvider.tsx
 import { jsx } from "react/jsx-runtime";
-var SQLite2 = new SQLite("modelaz.db");
 var DataStoreContext = createContext({});
 var DataStoreDocumentsContext = createContext({});
 var DataStoreProvidersContext = createContext({});
@@ -1002,1002 +872,1037 @@ var buildDocumentTemplateParams = (model, documentId) => {
     [templateIdKey]: documentId
   };
 };
-var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true, ...props }) => {
-  const [isLive, setIsLive] = useState(false);
-  const [isSynchronizing, setIsSynchronizing] = useState(true);
-  const [sockets, setSockets] = useState({});
-  const [providers, setProviders] = useState({});
-  const [documents, setDocuments] = useState({});
-  const externalProvidersRef = useRef({});
-  const externalDocumentsRef = useRef({});
-  const providerSubscribersRef = useRef(/* @__PURE__ */ new Map());
-  const previousProviderUpdateIdsRef = useRef({});
-  const [dispatcher, setDispatcher] = useState({ isBussy: false, actions: [] });
-  const [counterProviders, setCounterProviders] = useState({});
-  const [counterDocuments, setCounterDocuments] = useState({});
-  const didInitialLiveSyncRef = useRef(false);
-  useEffect(() => {
-    if (!restServer) return;
-    const localization = getLocales();
-    axios2.defaults.baseURL = restServer;
-    axios2.defaults.headers.common["Accept-Language"] = localization[0]?.languageCode;
-    systemLog("dsp", "[INIT] Axios baseURL:", restServer);
-    async function checkServer() {
-      try {
-        const response = await axios2.head("/", {
-          timeout: 7e3,
-          validateStatus: () => true
-        });
-        systemLog("dsp", "[INIT] Axios Success, status:", response.status);
-      } catch (e) {
-        if (axios2.isAxiosError(e)) {
-          systemLog("dsp", "[INIT] Axios Error:", e.code ?? "UNKNOWN", e.message);
-        } else {
-          systemLog("dsp", "[INIT] Axios Error:", String(e));
-        }
-      } finally {
-        systemLog("dsp", "[INIT] Axios check done");
-      }
+var resolveLocale = () => {
+  if (typeof Intl !== "undefined" && typeof Intl.DateTimeFormat === "function") {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (locale) return locale;
+  }
+  if (typeof navigator !== "undefined") {
+    if (typeof navigator.language === "string" && navigator.language.length > 0) {
+      return navigator.language;
     }
-    checkServer();
-  }, [restServer]);
-  const socketRoomHandlersRef = useRef({});
-  const socketActionHandlersRef = useRef({});
-  systemLog("dsp", "START");
-  const socket = useMemo(() => ioSockets(socketServer?.url, socketServer?.params), [socketServer?.url, socketServer.params]);
-  const handleSocketConnect = useCallback(() => setIsLive(true), []);
-  const handleSocketDisconnect = useCallback(() => setIsLive(false), []);
-  const getSocketAuthToken = useCallback(() => {
-    const authorizationHeader = axios2.defaults.headers.common["Authorization"];
-    if (typeof authorizationHeader === "string" && authorizationHeader.length > 0) {
-      return authorizationHeader.startsWith("Bearer ") ? authorizationHeader : `Bearer ${authorizationHeader}`;
+    if (Array.isArray(navigator.languages) && navigator.languages.length > 0) {
+      const firstLocale = navigator.languages.find((value) => typeof value === "string" && value.length > 0);
+      if (firstLocale) return firstLocale;
     }
-    return "Bearer ";
-  }, []);
-  const subscribeToProvider = useCallback((providerId, callback) => {
-    const subscribersByProvider = providerSubscribersRef.current;
-    const providerSubscribers = subscribersByProvider.get(providerId) || /* @__PURE__ */ new Set();
-    providerSubscribers.add(callback);
-    subscribersByProvider.set(providerId, providerSubscribers);
-    return () => {
-      const activeSubscribers = subscribersByProvider.get(providerId);
-      if (!activeSubscribers) return;
-      activeSubscribers.delete(callback);
-      if (activeSubscribers.size === 0) subscribersByProvider.delete(providerId);
-    };
-  }, []);
-  const getProviderLastUpdate = useCallback((providerId) => {
-    return externalProvidersRef.current?.[providerId]?.lastUpdate?.id ?? null;
-  }, []);
-  const getExternalDocuments = useCallback(() => externalDocumentsRef.current, []);
-  const getExternalProviders = useCallback(() => externalProvidersRef.current, []);
-  useEffect(() => {
-    externalProvidersRef.current = providers;
-    const currentUpdateIds = {};
-    Object.keys(providers).forEach((providerId) => {
-      currentUpdateIds[providerId] = providers[providerId]?.lastUpdate?.id ?? null;
-      if (previousProviderUpdateIdsRef.current[providerId] !== currentUpdateIds[providerId]) {
-        const subscribers = providerSubscribersRef.current.get(providerId);
-        subscribers?.forEach((callback) => callback());
+  }
+  return void 0;
+};
+var DataStoreProvider = forwardRef(
+  ({ socketServer, restServer, usePersistentStorage = true, locale, storage = null, ...props }, ref) => {
+    const [isLive, setIsLive] = useState(false);
+    const [isSynchronizing, setIsSynchronizing] = useState(true);
+    const [sockets, setSockets] = useState({});
+    const [providers, setProviders] = useState({});
+    const [documents, setDocuments] = useState({});
+    const externalProvidersRef = useRef({});
+    const externalDocumentsRef = useRef({});
+    const providerSubscribersRef = useRef(/* @__PURE__ */ new Map());
+    const previousProviderUpdateIdsRef = useRef({});
+    const [dispatcher, setDispatcher] = useState({ isBussy: false, actions: [] });
+    const [counterProviders, setCounterProviders] = useState({});
+    const [counterDocuments, setCounterDocuments] = useState({});
+    const didInitialLiveSyncRef = useRef(false);
+    const persistenceStorage = useMemo(
+      () => usePersistentStorage ? storage : null,
+      [storage, usePersistentStorage]
+    );
+    useEffect(() => {
+      if (!restServer) return;
+      const resolvedLocale = locale || resolveLocale();
+      axios2.defaults.baseURL = restServer;
+      if (resolvedLocale) {
+        axios2.defaults.headers.common["Accept-Language"] = resolvedLocale;
       }
-    });
-    Object.keys(previousProviderUpdateIdsRef.current).forEach((providerId) => {
-      if (!(providerId in currentUpdateIds)) {
-        const subscribers = providerSubscribersRef.current.get(providerId);
-        subscribers?.forEach((callback) => callback());
+      systemLog("dsp", "[INIT] Axios baseURL:", restServer);
+      async function checkServer() {
+        try {
+          const response = await axios2.head("/", {
+            timeout: 7e3,
+            validateStatus: () => true
+          });
+          systemLog("dsp", "[INIT] Axios Success, status:", response.status);
+        } catch (e) {
+          if (axios2.isAxiosError(e)) {
+            systemLog("dsp", "[INIT] Axios Error:", e.code ?? "UNKNOWN", e.message);
+          } else {
+            systemLog("dsp", "[INIT] Axios Error:", String(e));
+          }
+        } finally {
+          systemLog("dsp", "[INIT] Axios check done");
+        }
       }
-    });
-    previousProviderUpdateIdsRef.current = currentUpdateIds;
-  }, [providers]);
-  useEffect(() => {
-    externalDocumentsRef.current = documents;
-  }, [documents]);
-  const persistDocument = useCallback(
-    async ({
-      documentId,
-      model,
-      data,
-      lastUpdate = (/* @__PURE__ */ new Date()).toISOString()
-    }) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
+      checkServer();
+    }, [locale, restServer]);
+    useEffect(() => {
+      if (usePersistentStorage && !storage) {
+        systemLog("dsp", "[INIT] Persistence is enabled but no storage adapter was provided.");
+      }
+    }, [persistenceStorage, storage, usePersistentStorage]);
+    const socketRoomHandlersRef = useRef({});
+    const socketActionHandlersRef = useRef({});
+    systemLog("dsp", "START");
+    const socket = useMemo(() => ioSockets(socketServer?.url, socketServer?.params), [socketServer?.url, socketServer.params]);
+    const handleSocketConnect = useCallback(() => setIsLive(true), []);
+    const handleSocketDisconnect = useCallback(() => setIsLive(false), []);
+    const getSocketAuthToken = useCallback(() => {
+      const authorizationHeader = axios2.defaults.headers.common["Authorization"];
+      if (typeof authorizationHeader === "string" && authorizationHeader.length > 0) {
+        return authorizationHeader.startsWith("Bearer ") ? authorizationHeader : `Bearer ${authorizationHeader}`;
+      }
+      return "Bearer ";
+    }, []);
+    const subscribeToProvider = useCallback((providerId, callback) => {
+      const subscribersByProvider = providerSubscribersRef.current;
+      const providerSubscribers = subscribersByProvider.get(providerId) || /* @__PURE__ */ new Set();
+      providerSubscribers.add(callback);
+      subscribersByProvider.set(providerId, providerSubscribers);
+      return () => {
+        const activeSubscribers = subscribersByProvider.get(providerId);
+        if (!activeSubscribers) return;
+        activeSubscribers.delete(callback);
+        if (activeSubscribers.size === 0) subscribersByProvider.delete(providerId);
+      };
+    }, []);
+    const getProviderLastUpdate = useCallback((providerId) => {
+      return externalProvidersRef.current?.[providerId]?.lastUpdate?.id ?? null;
+    }, []);
+    const getExternalDocuments = useCallback(() => externalDocumentsRef.current, []);
+    const getExternalProviders = useCallback(() => externalProvidersRef.current, []);
+    useEffect(() => {
+      externalProvidersRef.current = providers;
+      const currentUpdateIds = {};
+      Object.keys(providers).forEach((providerId) => {
+        currentUpdateIds[providerId] = providers[providerId]?.lastUpdate?.id ?? null;
+        if (previousProviderUpdateIdsRef.current[providerId] !== currentUpdateIds[providerId]) {
+          const subscribers = providerSubscribersRef.current.get(providerId);
+          subscribers?.forEach((callback) => callback());
+        }
+      });
+      Object.keys(previousProviderUpdateIdsRef.current).forEach((providerId) => {
+        if (!(providerId in currentUpdateIds)) {
+          const subscribers = providerSubscribersRef.current.get(providerId);
+          subscribers?.forEach((callback) => callback());
+        }
+      });
+      previousProviderUpdateIdsRef.current = currentUpdateIds;
+    }, [providers]);
+    useEffect(() => {
+      externalDocumentsRef.current = documents;
+    }, [documents]);
+    const persistDocument = useCallback(
+      async ({
         documentId,
-        JSON.stringify(data),
         model,
-        lastUpdate
-      ]);
-    },
-    [usePersistentStorage]
-  );
-  const removePersistedDocument = useCallback(
-    async (documentId) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query("DELETE FROM documents WHERE id = ?", [documentId]);
-    },
-    [usePersistentStorage]
-  );
-  const synchronizeDataStore = useCallback(async () => {
-    setIsSynchronizing(true);
-    const stats = { processed: 0, updated: 0, failed: 0 };
-    try {
-      for (const key of Object.keys(providers)) {
-        stats.processed++;
-        try {
-          const { data, lastUpdate, ...rest } = providers[key];
-          const response = await getData({
-            id: key,
-            ...rest,
-            changeTime: lastUpdate.time
-          });
-          if (response.length > 0) {
-            const updateData = {};
-            response.forEach((item) => {
-              const { id, ...d } = item;
-              updateData[id] = d;
+        data,
+        lastUpdate = (/* @__PURE__ */ new Date()).toISOString()
+      }) => {
+        if (!persistenceStorage) return;
+        await persistenceStorage.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
+          documentId,
+          JSON.stringify(data),
+          model,
+          lastUpdate
+        ]);
+      },
+      [persistenceStorage]
+    );
+    const removePersistedDocument = useCallback(
+      async (documentId) => {
+        if (!persistenceStorage) return;
+        await persistenceStorage.query("DELETE FROM documents WHERE id = ?", [documentId]);
+      },
+      [persistenceStorage]
+    );
+    const synchronizeDataStore = useCallback(async () => {
+      setIsSynchronizing(true);
+      const stats = { processed: 0, updated: 0, failed: 0 };
+      try {
+        for (const key of Object.keys(providers)) {
+          stats.processed++;
+          try {
+            const { data, lastUpdate, ...rest } = providers[key];
+            const response = await getData({
+              id: key,
+              ...rest,
+              changeTime: lastUpdate.time
             });
-            await updateDocuments({ model: key, documents: updateData, mode: "replace" });
-            stats.updated++;
+            if (response.length > 0) {
+              const updateData = {};
+              response.forEach((item) => {
+                const { id, ...d } = item;
+                updateData[id] = d;
+              });
+              await updateDocuments({ model: key, documents: updateData, mode: "replace" });
+              stats.updated++;
+            }
+          } catch (e) {
+            stats.failed++;
+            console.error("[DSP] synchronizeDataStore provider error:", key, e);
           }
-        } catch (e) {
-          stats.failed++;
-          console.error("[DSP] synchronizeDataStore provider error:", key, e);
         }
+      } finally {
+        setIsSynchronizing(false);
+        systemLog("dsp", "[synchronizeDataStore] Hotovo:", stats);
       }
-    } finally {
-      setIsSynchronizing(false);
-      systemLog("dsp", "[synchronizeDataStore] Hotovo:", stats);
-    }
-  }, [providers]);
-  useEffect(() => {
-    if (isLive) {
-      systemLog("dsp", "useEffect[isLive] Sockets: ", JSON.stringify(sockets, null, 2));
-      const ss = Object.keys(sockets);
-      systemLog("dsp", "useEffect[isLive] registruji", ss);
-      if (ss?.length > 0) socket.emit("joinRooms", JSON.stringify(ss));
-      if (!didInitialLiveSyncRef.current) {
-        didInitialLiveSyncRef.current = true;
-        systemLog("dsp", "useEffect[isLive] Zacinam synchronizovat");
-        synchronizeDataStore();
+    }, [providers]);
+    useEffect(() => {
+      if (isLive) {
+        systemLog("dsp", "useEffect[isLive] Sockets: ", JSON.stringify(sockets, null, 2));
+        const ss = Object.keys(sockets);
+        systemLog("dsp", "useEffect[isLive] registruji", ss);
+        if (ss?.length > 0) socket.emit("joinRooms", JSON.stringify(ss));
+        if (!didInitialLiveSyncRef.current) {
+          didInitialLiveSyncRef.current = true;
+          systemLog("dsp", "useEffect[isLive] Zacinam synchronizovat");
+          synchronizeDataStore();
+        }
+      } else {
+        didInitialLiveSyncRef.current = false;
       }
-    } else {
-      didInitialLiveSyncRef.current = false;
-    }
-  }, [isLive, socket, sockets, synchronizeDataStore]);
-  const presetProviders = props.providers;
-  useEffect(() => {
-    socket.on("connect", handleSocketConnect);
-    socket.on("disconnect", handleSocketDisconnect);
-    return () => {
-      socket.off("connect", handleSocketConnect);
-      socket.off("disconnect", handleSocketDisconnect);
-    };
-  }, [socket, handleSocketConnect, handleSocketDisconnect]);
-  const startSockets = useCallback(() => {
-    socket.auth = {
-      ...socket.auth || {},
-      ...socketServer?.params?.auth || {},
-      token: getSocketAuthToken()
-    };
-    systemLog("dsp", "PRIPOJUJI LIVE SOCKETS");
-    socket.connect();
-  }, [socket, socketServer?.params?.auth, getSocketAuthToken]);
-  const stopSockets = useCallback(() => {
-    systemLog("dsp", "[DSP] ODPOJUJI LIVE SOCKETS");
-    socket.disconnect();
-  }, [socket]);
-  const resetDataStore = useCallback(async () => {
-    console.time("[DSP] resetDataStore");
-    if (usePersistentStorage) {
-      await SQLite2.emptyTable("documents");
-    }
-    setSockets({});
-    setProviders({});
-    setDocuments({});
-    setCounterProviders({});
-    setCounterDocuments({});
-    console.timeEnd("[DSP] resetDataStore");
-  }, [usePersistentStorage]);
-  const resetProvider = useCallback(
-    async (provider) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query(`DELETE FROM documents WHERE model='${provider}'`);
-    },
-    [usePersistentStorage]
-  );
-  const initProvider = useCallback(
-    async (id, data) => {
-      const providerPreset = presetProviders[id];
-      const prov = renderJSONTemplate({ ...providerPreset || {}, id }, data);
-      systemLog("dsp", "[INIT PROVIDER] ", id, "(", data || "", ")");
-      if (typeof prov !== "boolean") {
-        return await registerProvider(prov);
+    }, [isLive, socket, sockets, synchronizeDataStore]);
+    const presetProviders = props.providers;
+    useEffect(() => {
+      socket.on("connect", handleSocketConnect);
+      socket.on("disconnect", handleSocketDisconnect);
+      return () => {
+        socket.off("connect", handleSocketConnect);
+        socket.off("disconnect", handleSocketDisconnect);
+      };
+    }, [socket, handleSocketConnect, handleSocketDisconnect]);
+    const startSockets = useCallback(() => {
+      socket.auth = {
+        ...socket.auth || {},
+        ...socketServer?.params?.auth || {},
+        token: getSocketAuthToken()
+      };
+      systemLog("dsp", "PRIPOJUJI LIVE SOCKETS");
+      socket.connect();
+    }, [socket, socketServer?.params?.auth, getSocketAuthToken]);
+    const stopSockets = useCallback(() => {
+      systemLog("dsp", "[DSP] ODPOJUJI LIVE SOCKETS");
+      socket.disconnect();
+    }, [socket]);
+    const resetDataStore = useCallback(async () => {
+      console.time("[DSP] resetDataStore");
+      if (persistenceStorage?.emptyTable) {
+        await persistenceStorage.emptyTable("documents");
       }
-      return false;
-    },
-    [presetProviders]
-  );
-  const dispatch = useCallback((action, data, callback) => {
-    systemLog("dsp", "[DSP] DISPATCH Ukladam akci", action, ",", data);
-    setDispatcher((prev) => ({
-      isBussy: prev.isBussy,
-      actions: [...prev.actions, { action, data, callback }]
-    }));
-  }, []);
-  useEffect(() => {
-    async function processDispatcher() {
-      if (dispatcher.actions.length > 0) {
-        let result;
-        systemLog("dsp", "[DSP] DISPATCHER Zpracovavam", dispatcher.actions[0].action);
-        const timeCode = uuid();
-        console.time(`Dispatcher ${dispatcher.actions[0].action} ${timeCode}`);
-        setDispatcher((prev) => ({ ...prev, isBussy: true }));
-        const item = dispatcher.actions[0];
-        switch (item.action) {
-          case "registerProvider":
-            await registerProvider(item.data);
-            break;
-          case "unregisterProvider":
-            await unregisterProvider(item.data);
-            break;
-          case "updateDataStore":
-            result = await updateDataStore(item.data);
-            break;
-          case "createDocument":
-            await createDocument(item.data);
-            break;
-          case "updateDocument":
-            await updateDocument(item.data);
-            break;
-          case "updateDocuments":
-            await updateDocuments(item.data);
-            break;
-          case "removeItem":
-            break;
-          case "deleteDocument":
-            await deleteDocument(item.data);
-            break;
-          case "createProviderItem":
-            result = await createProviderItem(item.data);
-            break;
-          case "deleteProviderItem":
-            result = await deleteProviderItem(item.data);
-            break;
-          default:
-            console.error("Unknown Action ", item.action, "Data: ", item.data);
+      setSockets({});
+      setProviders({});
+      setDocuments({});
+      setCounterProviders({});
+      setCounterDocuments({});
+      console.timeEnd("[DSP] resetDataStore");
+    }, [persistenceStorage]);
+    const resetProvider = useCallback(
+      async (provider) => {
+        if (!persistenceStorage) return;
+        await persistenceStorage.query(`DELETE FROM documents WHERE model='${provider}'`);
+      },
+      [persistenceStorage]
+    );
+    const initProvider = useCallback(
+      async (id, data) => {
+        const providerPreset = presetProviders[id];
+        const prov = renderJSONTemplate({ ...providerPreset || {}, id }, data);
+        systemLog("dsp", "[INIT PROVIDER] ", id, "(", data || "", ")");
+        if (typeof prov !== "boolean") {
+          return await registerProvider(prov);
+        }
+        return false;
+      },
+      [persistenceStorage, presetProviders, usePersistentStorage]
+    );
+    const dispatch = useCallback((action, data, callback) => {
+      systemLog("dsp", "[DSP] DISPATCH Ukladam akci", action, ",", data);
+      setDispatcher((prev) => ({
+        isBussy: prev.isBussy,
+        actions: [...prev.actions, { action, data, callback }]
+      }));
+    }, []);
+    useEffect(() => {
+      async function processDispatcher() {
+        if (dispatcher.actions.length > 0) {
+          let result;
+          systemLog("dsp", "[DSP] DISPATCHER Zpracovavam", dispatcher.actions[0].action);
+          const timeCode = uuid();
+          console.time(`Dispatcher ${dispatcher.actions[0].action} ${timeCode}`);
+          setDispatcher((prev) => ({ ...prev, isBussy: true }));
+          const item = dispatcher.actions[0];
+          switch (item.action) {
+            case "registerProvider":
+              await registerProvider(item.data);
+              break;
+            case "unregisterProvider":
+              await unregisterProvider(item.data);
+              break;
+            case "updateDataStore":
+              result = await updateDataStore(item.data);
+              break;
+            case "createDocument":
+              await createDocument(item.data);
+              break;
+            case "updateDocument":
+              await updateDocument(item.data);
+              break;
+            case "updateDocuments":
+              await updateDocuments(item.data);
+              break;
+            case "removeItem":
+              break;
+            case "deleteDocument":
+              await deleteDocument(item.data);
+              break;
+            case "createProviderItem":
+              result = await createProviderItem(item.data);
+              break;
+            case "deleteProviderItem":
+              result = await deleteProviderItem(item.data);
+              break;
+            default:
+              console.error("Unknown Action ", item.action, "Data: ", item.data);
+          }
+          item.callback && item.callback(result);
+          setDispatcher((prev) => ({
+            isBussy: false,
+            actions: prev.actions.slice(1)
+          }));
+          console.timeEnd(`Dispatcher ${dispatcher.actions[0].action} ${timeCode}`);
         }
-        item.callback && item.callback(result);
-        setDispatcher((prev) => ({
-          isBussy: false,
-          actions: prev.actions.slice(1)
-        }));
-        console.timeEnd(`Dispatcher ${dispatcher.actions[0].action} ${timeCode}`);
-      }
-    }
-    if (!dispatcher.isBussy) processDispatcher();
-  }, [dispatcher]);
-  const updateDocuments = useCallback(
-    async ({
-      model,
-      documents: uDocuments,
-      mode = "update"
-    }) => {
-      systemLog("dsp", "[DSP] updateDocuments updatuji model:", model, "Documents:", Object.keys(uDocuments).length);
-      const modelProvider = providers[model];
-      if (!modelProvider) {
-        systemLog("dsp", "[DSP] updateDocuments - provider neexistuje:", model);
-        return;
       }
-      let data = [...modelProvider.data || []];
-      const documentsToPersist = [];
-      const documentIdsToDelete = [];
-      setDocuments((prev) => {
-        console.time("updateDocuments");
-        let newDocs = { ...prev };
-        if (Array.isArray(uDocuments)) {
-          uDocuments.forEach((document) => {
-            const { id, ...doc } = document;
-            switch (mode) {
-              case "replace":
-                systemLog("dsp", "updateDocuments - replace", id);
-                newDocs[id] = doc;
-                if (doc._deleted) {
-                  data = data.filter((d) => d !== id);
-                  documentIdsToDelete.push(id);
-                  delete newDocs[id];
-                } else {
-                  if (!data.includes(id)) data.push(id);
-                  documentsToPersist.push({ id, data: newDocs[id] });
-                }
-                break;
-              case "update":
-              default:
-                if (!newDocs[id]) {
-                  systemLog("dsp", "updateDocuments - vytvarim", id);
-                  data.push(id);
+      if (!dispatcher.isBussy) processDispatcher();
+    }, [dispatcher]);
+    const updateDocuments = useCallback(
+      async ({
+        model,
+        documents: uDocuments,
+        mode = "update"
+      }) => {
+        systemLog("dsp", "[DSP] updateDocuments updatuji model:", model, "Documents:", Object.keys(uDocuments).length);
+        const modelProvider = providers[model];
+        if (!modelProvider) {
+          systemLog("dsp", "[DSP] updateDocuments - provider neexistuje:", model);
+          return;
+        }
+        let data = [...modelProvider.data || []];
+        const documentsToPersist = [];
+        const documentIdsToDelete = [];
+        setDocuments((prev) => {
+          console.time("updateDocuments");
+          let newDocs = { ...prev };
+          if (Array.isArray(uDocuments)) {
+            uDocuments.forEach((document) => {
+              const { id, ...doc } = document;
+              switch (mode) {
+                case "replace":
+                  systemLog("dsp", "updateDocuments - replace", id);
                   newDocs[id] = doc;
-                  documentsToPersist.push({ id, data: newDocs[id] });
-                } else if (doc._deleted) {
-                  systemLog("dsp", "updateDocuments - mazu", id);
-                  data = data.filter((d) => d !== id);
-                  documentIdsToDelete.push(id);
-                  delete newDocs[id];
-                } else {
-                  systemLog("dsp", "updateDocuments - updatuji", id);
-                  newDocs[id] = { ...newDocs[id], ...doc };
-                  documentsToPersist.push({ id, data: newDocs[id] });
-                }
-                break;
-            }
-          });
-        } else {
-          for (const key in uDocuments) {
-            switch (mode) {
-              case "replace":
-                if (!newDocs[key]) {
-                  data.push(key);
-                }
-                if (uDocuments[key]._deleted) {
-                  data = data.filter((d) => d !== key);
-                  documentIdsToDelete.push(key);
-                }
-                newDocs[key] = uDocuments[key];
-                if (uDocuments[key]._deleted) {
-                  delete newDocs[key];
-                } else {
-                  documentsToPersist.push({ id: key, data: newDocs[key] });
-                }
-                break;
-              case "update":
-              default:
-                if (!newDocs[key]) {
-                  data.push(key);
+                  if (doc._deleted) {
+                    data = data.filter((d) => d !== id);
+                    documentIdsToDelete.push(id);
+                    delete newDocs[id];
+                  } else {
+                    if (!data.includes(id)) data.push(id);
+                    documentsToPersist.push({ id, data: newDocs[id] });
+                  }
+                  break;
+                case "update":
+                default:
+                  if (!newDocs[id]) {
+                    systemLog("dsp", "updateDocuments - vytvarim", id);
+                    data.push(id);
+                    newDocs[id] = doc;
+                    documentsToPersist.push({ id, data: newDocs[id] });
+                  } else if (doc._deleted) {
+                    systemLog("dsp", "updateDocuments - mazu", id);
+                    data = data.filter((d) => d !== id);
+                    documentIdsToDelete.push(id);
+                    delete newDocs[id];
+                  } else {
+                    systemLog("dsp", "updateDocuments - updatuji", id);
+                    newDocs[id] = { ...newDocs[id], ...doc };
+                    documentsToPersist.push({ id, data: newDocs[id] });
+                  }
+                  break;
+              }
+            });
+          } else {
+            for (const key in uDocuments) {
+              switch (mode) {
+                case "replace":
+                  if (!newDocs[key]) {
+                    data.push(key);
+                  }
+                  if (uDocuments[key]._deleted) {
+                    data = data.filter((d) => d !== key);
+                    documentIdsToDelete.push(key);
+                  }
                   newDocs[key] = uDocuments[key];
-                  documentsToPersist.push({ id: key, data: newDocs[key] });
+                  if (uDocuments[key]._deleted) {
+                    delete newDocs[key];
+                  } else {
+                    documentsToPersist.push({ id: key, data: newDocs[key] });
+                  }
                   break;
-                }
-                if (uDocuments[key]._deleted) {
-                  data = data.filter((d) => d !== key);
-                  documentIdsToDelete.push(key);
-                  delete newDocs[key];
-                } else {
-                  newDocs[key] = { ...newDocs[key], ...uDocuments[key] };
-                  documentsToPersist.push({ id: key, data: newDocs[key] });
-                }
-                break;
+                case "update":
+                default:
+                  if (!newDocs[key]) {
+                    data.push(key);
+                    newDocs[key] = uDocuments[key];
+                    documentsToPersist.push({ id: key, data: newDocs[key] });
+                    break;
+                  }
+                  if (uDocuments[key]._deleted) {
+                    data = data.filter((d) => d !== key);
+                    documentIdsToDelete.push(key);
+                    delete newDocs[key];
+                  } else {
+                    newDocs[key] = { ...newDocs[key], ...uDocuments[key] };
+                    documentsToPersist.push({ id: key, data: newDocs[key] });
+                  }
+                  break;
+              }
             }
           }
+          console.timeEnd("updateDocuments");
+          return newDocs;
+        });
+        const unique = uuid();
+        setProviders((prev) => {
+          const newP = { ...prev };
+          newP[model] = {
+            ...newP[model],
+            data,
+            lastUpdate: { id: unique, time: /* @__PURE__ */ new Date() }
+          };
+          return newP;
+        });
+        if (modelProvider?.isPersisting && persistenceStorage) {
+          await Promise.all(documentsToPersist.map((item) => persistDocument({ documentId: item.id, model, data: item.data })));
+          await Promise.all(documentIdsToDelete.map((documentId) => removePersistedDocument(documentId)));
         }
-        console.timeEnd("updateDocuments");
-        return newDocs;
-      });
-      const unique = uuid();
-      setProviders((prev) => {
-        const newP = { ...prev };
-        newP[model] = {
-          ...newP[model],
-          data,
-          lastUpdate: { id: unique, time: /* @__PURE__ */ new Date() }
-        };
-        return newP;
-      });
-      if (modelProvider?.isPersisting && usePersistentStorage) {
-        await Promise.all(documentsToPersist.map((item) => persistDocument({ documentId: item.id, model, data: item.data })));
-        await Promise.all(documentIdsToDelete.map((documentId) => removePersistedDocument(documentId)));
-      }
-    },
-    [providers, setDocuments, setProviders, persistDocument, removePersistedDocument]
-  );
-  const updateDocument = useCallback(
-    async ({ documentId, model, fields, data: pData }) => {
-      systemLog("dsp", "[updateDocument]:", documentId, ", model:", model);
-      let data = pData;
-      if (typeof pData === "function") data = pData(documents[documentId]);
-      if (fields) {
-        systemLog("dsp", "[updateDocument] Stahovani ", model, ", document: ", documentId, ", fields: ", fields);
-        systemLog("dsp", "[updateDocument] Providers: ", Object.keys(providers));
-        const provider = presetProviders[model];
-        systemLog("dsp", "[updateDocument]", provider);
-        let dP = renderJSONTemplate(presetProviders[model], buildDocumentTemplateParams(model, documentId));
-        if (dP) {
-          const dataFromSource = await getData({
-            id: dP.id,
-            dataSource: { ...dP.dataSource, params: { select: fields.join(" ") } },
-            isPersisting: !!dP.isPersisting && usePersistentStorage,
-            schema: dP.schema,
-            SQLite: SQLite2
-          });
-          systemLog("dsp", "[updateDocument] DATA: ", dataFromSource);
-          data = dataFromSource;
+      },
+      [providers, setDocuments, setProviders, persistDocument, removePersistedDocument, persistenceStorage]
+    );
+    const updateDocument = useCallback(
+      async ({ documentId, model, fields, data: pData }) => {
+        systemLog("dsp", "[updateDocument]:", documentId, ", model:", model);
+        let data = pData;
+        if (typeof pData === "function") data = pData(documents[documentId]);
+        if (fields) {
+          systemLog("dsp", "[updateDocument] Stahovani ", model, ", document: ", documentId, ", fields: ", fields);
+          systemLog("dsp", "[updateDocument] Providers: ", Object.keys(providers));
+          const provider = presetProviders[model];
+          systemLog("dsp", "[updateDocument]", provider);
+          let dP = renderJSONTemplate(presetProviders[model], buildDocumentTemplateParams(model, documentId));
+          if (dP) {
+            const dataFromSource = await getData({
+              id: dP.id,
+              dataSource: { ...dP.dataSource, params: { select: fields.join(" ") } },
+              isPersisting: !!dP.isPersisting && !!persistenceStorage,
+              schema: dP.schema,
+              SQLite: persistenceStorage || void 0
+            });
+            systemLog("dsp", "[updateDocument] DATA: ", dataFromSource);
+            data = dataFromSource;
+          }
         }
-      }
-      if (data) {
-        var listeningProviders = 0;
-        var isProvidersUpdated = false;
-        const rand = uuid();
-        setProviders((prev) => {
-          systemLog("dsp", "[updateDocument] setProviders", rand);
-          console.time("[DSP UPDATE PROVIDERS INSIDE]");
-          var newProviders = { ...prev };
-          Object.keys(newProviders).forEach((key) => {
-            const provider = newProviders[key];
-            const providerNext = {
-              ...provider,
-              data: Array.isArray(provider?.data) ? [...provider.data] : []
-            };
-            var socketListeners = providerNext.dataSource?.socketListeners || [];
-            if (socketListeners.length === 0) {
-              if (providerNext.data.includes(documentId)) {
-                if (!providerNext.dataSource?.filter || filterDocuments(data, providerNext.dataSource?.filter)) {
-                  systemLog("dsp", "[updateDocument] - zustava v Provider bez Listeners:", key);
+        if (data) {
+          var listeningProviders = 0;
+          var isProvidersUpdated = false;
+          const rand = uuid();
+          setProviders((prev) => {
+            systemLog("dsp", "[updateDocument] setProviders", rand);
+            console.time("[DSP UPDATE PROVIDERS INSIDE]");
+            var newProviders = { ...prev };
+            Object.keys(newProviders).forEach((key) => {
+              const provider = newProviders[key];
+              const providerNext = {
+                ...provider,
+                data: Array.isArray(provider?.data) ? [...provider.data] : []
+              };
+              var socketListeners = providerNext.dataSource?.socketListeners || [];
+              if (socketListeners.length === 0) {
+                if (providerNext.data.includes(documentId)) {
+                  if (!providerNext.dataSource?.filter || filterDocuments(data, providerNext.dataSource?.filter)) {
+                    systemLog("dsp", "[updateDocument] - zustava v Provider bez Listeners:", key);
+                    listeningProviders++;
+                    providerNext.lastUpdate = {
+                      id: uuid(),
+                      time: /* @__PURE__ */ new Date(),
+                      documentId
+                    };
+                  } else {
+                    providerNext.data = providerNext.data.filter((item) => item !== documentId);
+                    isProvidersUpdated = true;
+                    providerNext.lastUpdate = {
+                      id: uuid(),
+                      time: /* @__PURE__ */ new Date(),
+                      documentId
+                    };
+                  }
+                }
+              } else if (socketListeners.includes(model) || // socketListeners.includes(documentId) ||
+              key === model) {
+                if (!providerNext.dataSource.filter || filterDocuments(data, providerNext.dataSource.filter)) {
                   listeningProviders++;
                   providerNext.lastUpdate = {
                     id: uuid(),
                     time: /* @__PURE__ */ new Date(),
                     documentId
                   };
+                  if (!providerNext.data.includes(documentId)) {
+                    providerNext.data.push(documentId);
+                    isProvidersUpdated = true;
+                  }
                 } else {
-                  providerNext.data = providerNext.data.filter((item) => item !== documentId);
-                  isProvidersUpdated = true;
-                  providerNext.lastUpdate = {
-                    id: uuid(),
-                    time: /* @__PURE__ */ new Date(),
-                    documentId
-                  };
+                  if (providerNext.data.includes(documentId)) {
+                    systemLog("dsp", "[updateDocument] - mazu:", key);
+                    providerNext.data = providerNext.data.filter((item) => item !== documentId);
+                    isProvidersUpdated = true;
+                    providerNext.lastUpdate = {
+                      id: uuid(),
+                      time: /* @__PURE__ */ new Date(),
+                      documentId
+                    };
+                  }
                 }
               }
-            } else if (socketListeners.includes(model) || // socketListeners.includes(documentId) ||
-            key === model) {
-              if (!providerNext.dataSource.filter || filterDocuments(data, providerNext.dataSource.filter)) {
-                listeningProviders++;
-                providerNext.lastUpdate = {
-                  id: uuid(),
-                  time: /* @__PURE__ */ new Date(),
-                  documentId
-                };
-                if (!providerNext.data.includes(documentId)) {
-                  providerNext.data.push(documentId);
-                  isProvidersUpdated = true;
-                }
-              } else {
-                if (providerNext.data.includes(documentId)) {
-                  systemLog("dsp", "[updateDocument] - mazu:", key);
-                  providerNext.data = providerNext.data.filter((item) => item !== documentId);
-                  isProvidersUpdated = true;
-                  providerNext.lastUpdate = {
-                    id: uuid(),
-                    time: /* @__PURE__ */ new Date(),
-                    documentId
+              newProviders[key] = providerNext;
+            });
+            console.timeEnd("[DSP UPDATE PROVIDERS INSIDE]");
+            console.time("[DSP UPDATE DOCUMENTS OUTSIDE]");
+            setDocuments((prev2) => {
+              console.time("[DSP UPDATE DOCUMENTS INSIDE]");
+              if (prev2[documentId]) {
+                if (listeningProviders === 0) {
+                  const newD = { ...prev2 };
+                  delete newD[documentId];
+                  console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
+                  return newD;
+                } else {
+                  console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
+                  return {
+                    ...prev2,
+                    [documentId]: { ...prev2[documentId], ...data }
                   };
                 }
+              } else if (listeningProviders > 0) {
+                console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
+                return { ...prev2, [documentId]: data };
               }
-            }
-            newProviders[key] = providerNext;
+              console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
+              return prev2;
+            });
+            console.timeEnd("[DSP UPDATE DOCUMENTS OUTSIDE]");
+            systemLog("dsp", "OUTSIDE", documentId);
+            return newProviders;
           });
-          console.timeEnd("[DSP UPDATE PROVIDERS INSIDE]");
-          console.time("[DSP UPDATE DOCUMENTS OUTSIDE]");
-          setDocuments((prev2) => {
-            console.time("[DSP UPDATE DOCUMENTS INSIDE]");
-            if (prev2[documentId]) {
+          systemLog("dsp", "updateDocument - meni se pocet naslouchajicich Provideru ?", isProvidersUpdated ? "true" : "false");
+          if (isProvidersUpdated) {
+            systemLog("dsp", "updateDocument - menim counterDocuments pro", listeningProviders, "Providers");
+            setCounterDocuments((prev) => {
               if (listeningProviders === 0) {
-                const newD = { ...prev2 };
+                const newD = { ...prev };
                 delete newD[documentId];
-                console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
                 return newD;
               } else {
-                console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
-                return {
-                  ...prev2,
-                  [documentId]: { ...prev2[documentId], ...data }
-                };
+                return { ...prev, [documentId]: listeningProviders };
               }
-            } else if (listeningProviders > 0) {
-              console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
-              return { ...prev2, [documentId]: data };
-            }
-            console.timeEnd("[DSP UPDATE DOCUMENTS INSIDE]");
-            return prev2;
-          });
-          console.timeEnd("[DSP UPDATE DOCUMENTS OUTSIDE]");
-          systemLog("dsp", "OUTSIDE", documentId);
-          return newProviders;
-        });
-        systemLog("dsp", "updateDocument - meni se pocet naslouchajicich Provideru ?", isProvidersUpdated ? "true" : "false");
-        if (isProvidersUpdated) {
-          systemLog("dsp", "updateDocument - menim counterDocuments pro", listeningProviders, "Providers");
-          setCounterDocuments((prev) => {
-            if (listeningProviders === 0) {
-              const newD = { ...prev };
-              delete newD[documentId];
-              return newD;
-            } else {
-              return { ...prev, [documentId]: listeningProviders };
-            }
-          });
-        } else {
-          systemLog("dsp", "updateDocument - nemenim counterDocuments. Dokument zustava v", listeningProviders, "Providers");
-        }
-        if (providers[model]?.isPersisting && usePersistentStorage) {
-          if (listeningProviders > 0) {
-            await persistDocument({
-              documentId,
-              model,
-              data: { ...documents[documentId], ...data }
             });
           } else {
-            await removePersistedDocument(documentId);
+            systemLog("dsp", "updateDocument - nemenim counterDocuments. Dokument zustava v", listeningProviders, "Providers");
+          }
+          if (providers[model]?.isPersisting && persistenceStorage) {
+            if (listeningProviders > 0) {
+              await persistDocument({
+                documentId,
+                model,
+                data: { ...documents[documentId], ...data }
+              });
+            } else {
+              await removePersistedDocument(documentId);
+            }
           }
         }
-      }
-    },
-    [documents, providers, setDocuments, setProviders, setCounterDocuments, persistDocument, removePersistedDocument]
-  );
-  const updateDataStore = useCallback(
-    async ({
-      id,
-      documentId,
-      params,
-      variant,
-      data
-    }) => {
-      if (!providers[id]) {
-        systemLog("dsp", "[updateDataStore] Provider neexistuje:", id);
-        return;
-      }
-      if (!providers[id].dataSource?.uri && !providers[id].dataSource?.crud) {
-        if (!documents[documentId] && providers[id]?.autoCreate) {
-          await createProviderItem({ id, data: { id: documentId, ...data } });
-        } else updateDocument({ documentId, model: id, data });
-        return true;
-      }
-      systemLog(
-        "dsp",
-        "[updateDataStore] Posilam patchData: ",
+      },
+      [documents, providers, setDocuments, setProviders, setCounterDocuments, persistDocument, removePersistedDocument, persistenceStorage]
+    );
+    const updateDataStore = useCallback(
+      async ({
         id,
-        ",\n params: ",
-        JSON.stringify(params, null, 2),
-        "\n data: ",
-        JSON.stringify(data, null, 2)
-      );
-      const result = await patchData({
-        dataSource: renderJSONTemplate(providers[id].dataSource, params),
+        documentId,
+        params,
         variant,
         data
-      });
-      if (typeof result === "object") {
-        const { id: rDocumentId, ...document } = result;
-        if (!isLive) {
-          systemLog("dsp", "[updateDataStore] UPDATE DATA STORE RESULT: ", result);
-          updateDocument({ documentId: rDocumentId, model: id, data: document });
-        } else {
-          systemLog("dsp", "[updateDataStore] Updatuje Socket");
+      }) => {
+        if (!providers[id]) {
+          systemLog("dsp", "[updateDataStore] Provider neexistuje:", id);
+          return;
         }
-      }
-      return result;
-    },
-    [providers, documents, isLive, updateDocument]
-  );
-  useEffect(() => {
-    socketActionHandlersRef.current = { dispatch, updateDocument };
-  }, [dispatch, updateDocument]);
-  const createDocument = useCallback(
-    async ({ model, documentId, data }) => {
-      const newDocument = data;
-      systemLog("dsp", `Registruji model ${model}, documentId ${documentId}, data: ${JSON.stringify(data)}`);
-      var providerListenersCount = 0;
-      Object.keys(providers).forEach((key) => {
-        const provider = providers[key];
-        var socketListeners = provider.dataSource?.socketListeners;
-        if ((socketListeners?.includes(model) || key === model) && (!provider.dataSource?.filter || filterDocuments(data, provider.dataSource?.filter))) {
-          systemLog("dsp", "[createDocument] Provider data: ", provider.data.length, " Bytes, documentId: ", documentId);
-          if (!provider.data.includes(documentId)) {
-            providerListenersCount++;
-            setProviders((prev) => ({
-              ...prev,
-              [key]: {
-                ...prev[key],
-                data: [...prev[key].data, documentId],
-                lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
-              }
-            }));
-          }
+        if (!providers[id].dataSource?.uri && !providers[id].dataSource?.crud) {
+          if (!documents[documentId] && providers[id]?.autoCreate) {
+            await createProviderItem({ id, data: { id: documentId, ...data } });
+          } else updateDocument({ documentId, model: id, data });
+          return true;
         }
-      });
-      if (providerListenersCount > 0) {
-        if (providers[model]?.isPersisting && usePersistentStorage) {
-          await persistDocument({ documentId, model, data: newDocument });
-        }
-        setCounterDocuments((prev) => {
-          const newC = { ...prev };
-          if (newC[documentId]) {
-            setDocuments((prev2) => ({
-              ...prev2,
-              [documentId]: { ...prev2[documentId], ...newDocument }
-            }));
-            newC[documentId] = prev[documentId] + providerListenersCount;
+        systemLog(
+          "dsp",
+          "[updateDataStore] Posilam patchData: ",
+          id,
+          ",\n params: ",
+          JSON.stringify(params, null, 2),
+          "\n data: ",
+          JSON.stringify(data, null, 2)
+        );
+        const result = await patchData({
+          dataSource: renderJSONTemplate(providers[id].dataSource, params),
+          variant,
+          data
+        });
+        if (typeof result === "object") {
+          const { id: rDocumentId, ...document } = result;
+          if (!isLive) {
+            systemLog("dsp", "[updateDataStore] UPDATE DATA STORE RESULT: ", result);
+            updateDocument({ documentId: rDocumentId, model: id, data: document });
           } else {
-            setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
-            newC[documentId] = providerListenersCount;
+            systemLog("dsp", "[updateDataStore] Updatuje Socket");
           }
-          return newC;
-        });
-        return { id: documentId, document: newDocument };
-      } else return false;
-    },
-    [providers, setProviders, setCounterDocuments, setDocuments, persistDocument]
-  );
-  const deleteDocument = useCallback(
-    async ({ documentId }) => {
-      systemLog("dsp", `[deleteDocument] Mazu document ${documentId}}`);
-      await removePersistedDocument(documentId);
-      setDocuments((prev) => {
-        const newDocs = { ...prev };
-        systemLog("dsp", "[deleteDocument] MAZU ", documentId, " z ", newDocs);
-        delete newDocs[documentId];
-        systemLog("dsp", "[deleteDocument] NEW DOCS: ", newDocs);
-        return newDocs;
-      });
-      setCounterDocuments((prev) => {
-        const newC = { ...prev };
-        delete newC[documentId];
-        return newC;
-      });
-      setProviders((prev) => {
-        var deletedCount = 0;
-        const updatedDataObj = { ...prev };
-        for (const key in updatedDataObj) {
-          const initialLength = updatedDataObj[key].data.length;
-          updatedDataObj[key].data = updatedDataObj[key].data.filter((element) => element !== documentId);
-          updatedDataObj[key].lastUpdate = { id: uuid(), time: /* @__PURE__ */ new Date() };
-          deletedCount += initialLength - updatedDataObj[key].data.length;
-          if (initialLength - updatedDataObj[key].data.length > 0) systemLog("dsp", "[deleteDocument] Smazan zaznam...", deletedCount);
         }
-        return updatedDataObj;
-      });
-    },
-    [setDocuments, setCounterDocuments, setProviders, removePersistedDocument]
-  );
-  const createProviderItem = useCallback(
-    async ({ id, data }) => {
-      if (!providers[id]) {
-        systemLog("dsp", "[createProviderItem] Provider neexistuje:", id);
-        return;
-      }
-      if (!providers[id].dataSource) {
-        const { id: dId, ...rData } = data;
-        const documentId = dId || uuid();
-        const result2 = createDocument({ model: id, documentId, data: rData });
-        return result2;
-      }
-      const result = await postData({
-        dataSource: providers[id].dataSource,
-        schema: providers[id].schema,
-        val: data
-      });
-      return result;
-    },
-    [providers, createDocument]
-  );
-  const deleteProviderItem = useCallback(
-    async ({ providerId, data, params }) => {
-      if (!providers[providerId]) {
-        systemLog("dsp", "[deleteProviderItem] Provider neexistuje:", providerId);
-        return;
-      }
-      const response = await deleteData({
-        dataSource: renderJSONTemplate(providers[providerId].dataSource, params),
-        // dataSource: providers[providerId].dataSource,
-        data
-      });
-      return response;
-    },
-    [providers]
-  );
-  const registerProviderSockets = useCallback(
-    (sockets2) => {
-      if (sockets2) {
-        systemLog("dsp", "[registerProviderSockets]", sockets2);
-        var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
-        setSockets((prev) => {
-          const newS = { ...prev };
-          d.forEach((item) => {
-            if (newS[item]) {
-              newS[item].listeners = newS[item].listeners + 1;
+        return result;
+      },
+      [providers, documents, isLive, updateDocument]
+    );
+    useEffect(() => {
+      socketActionHandlersRef.current = { dispatch, updateDocument };
+    }, [dispatch, updateDocument]);
+    const createDocument = useCallback(
+      async ({ model, documentId, data }) => {
+        const newDocument = data;
+        systemLog("dsp", `Registruji model ${model}, documentId ${documentId}, data: ${JSON.stringify(data)}`);
+        var providerListenersCount = 0;
+        Object.keys(providers).forEach((key) => {
+          const provider = providers[key];
+          var socketListeners = provider.dataSource?.socketListeners;
+          if ((socketListeners?.includes(model) || key === model) && (!provider.dataSource?.filter || filterDocuments(data, provider.dataSource?.filter))) {
+            systemLog("dsp", "[createDocument] Provider data: ", provider.data.length, " Bytes, documentId: ", documentId);
+            if (!provider.data.includes(documentId)) {
+              providerListenersCount++;
+              setProviders((prev) => ({
+                ...prev,
+                [key]: {
+                  ...prev[key],
+                  data: [...prev[key].data, documentId],
+                  lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
+                }
+              }));
+            }
+          }
+        });
+        if (providerListenersCount > 0) {
+          if (providers[model]?.isPersisting && persistenceStorage) {
+            await persistDocument({ documentId, model, data: newDocument });
+          }
+          setCounterDocuments((prev) => {
+            const newC = { ...prev };
+            if (newC[documentId]) {
+              setDocuments((prev2) => ({
+                ...prev2,
+                [documentId]: { ...prev2[documentId], ...newDocument }
+              }));
+              newC[documentId] = prev[documentId] + providerListenersCount;
             } else {
-              const roomHandler = (msg) => {
-                const { dispatch: currentDispatch, updateDocument: currentUpdateDocument } = socketActionHandlersRef.current;
-                handleSocketMessage(item, msg, {
-                  dispatch: currentDispatch,
-                  updateDocument: currentUpdateDocument
-                });
-              };
-              socketRoomHandlersRef.current[item] = roomHandler;
-              newS[item] = { listeners: 1, data: [] };
-              socket.emit("joinRoom", item);
-              socket.on(item, roomHandler);
+              setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
+              newC[documentId] = providerListenersCount;
             }
+            return newC;
           });
-          return newS;
+          return { id: documentId, document: newDocument };
+        } else return false;
+      },
+      [providers, setProviders, setCounterDocuments, setDocuments, persistDocument, persistenceStorage]
+    );
+    const deleteDocument = useCallback(
+      async ({ documentId }) => {
+        systemLog("dsp", `[deleteDocument] Mazu document ${documentId}}`);
+        await removePersistedDocument(documentId);
+        setDocuments((prev) => {
+          const newDocs = { ...prev };
+          systemLog("dsp", "[deleteDocument] MAZU ", documentId, " z ", newDocs);
+          delete newDocs[documentId];
+          systemLog("dsp", "[deleteDocument] NEW DOCS: ", newDocs);
+          return newDocs;
         });
-      }
-    },
-    [setSockets, socket]
-  );
-  const unregisterProviderSockets = useCallback(
-    (sockets2) => {
-      systemLog("dsp", "[unregisterProviderSockets] Mazu sockety ", JSON.stringify(sockets2, null, 2));
-      var removeSocketListeners = [];
-      var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
-      setSockets((prev) => {
-        const newS = { ...prev };
-        d.forEach((item) => {
-          if (newS[item]?.listeners <= 1) {
-            removeSocketListeners.push(item);
-            const roomHandler = socketRoomHandlersRef.current[item];
-            if (roomHandler) {
-              socket.off(item, roomHandler);
-              delete socketRoomHandlersRef.current[item];
-            }
-            delete newS[item];
-          } else if (newS[item]) newS[item].listeners = newS[item].listeners - 1;
+        setCounterDocuments((prev) => {
+          const newC = { ...prev };
+          delete newC[documentId];
+          return newC;
+        });
+        setProviders((prev) => {
+          var deletedCount = 0;
+          const updatedDataObj = { ...prev };
+          for (const key in updatedDataObj) {
+            const initialLength = updatedDataObj[key].data.length;
+            updatedDataObj[key].data = updatedDataObj[key].data.filter((element) => element !== documentId);
+            updatedDataObj[key].lastUpdate = { id: uuid(), time: /* @__PURE__ */ new Date() };
+            deletedCount += initialLength - updatedDataObj[key].data.length;
+            if (initialLength - updatedDataObj[key].data.length > 0) systemLog("dsp", "[deleteDocument] Smazan zaznam...", deletedCount);
+          }
+          return updatedDataObj;
         });
-        if (removeSocketListeners.length > 0) {
-          socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
+      },
+      [setDocuments, setCounterDocuments, setProviders, removePersistedDocument]
+    );
+    const createProviderItem = useCallback(
+      async ({ id, data }) => {
+        if (!providers[id]) {
+          systemLog("dsp", "[createProviderItem] Provider neexistuje:", id);
+          return;
         }
-        return newS;
-      });
-    },
-    [setSockets, socket]
-  );
-  const updateProviderListeners = useCallback(
-    async (id, val) => {
-      systemLog("dsp", `[updateProviderListeners] provider:`, id, "menim o", val);
-      setCounterProviders((prev) => {
-        if (!prev[id]) return prev;
-        if (prev[id] + val > 0) {
-          return {
-            ...prev,
-            [id]: prev[id] + val
-          };
-        } else {
-          setProviders((prevP) => {
-            systemLog("dsp", "[DSP] UPDATE PROVIDER - mazu sockets ", id);
-            setSockets((prevS) => {
-              var removeSocketListeners = [];
-              const newS = { ...prevS };
-              const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
-              providerSocketListeners.forEach((socketName) => {
-                if (!newS[socketName]) return;
-                if (newS[socketName].listeners + val <= 0) {
-                  const roomHandler = socketRoomHandlersRef.current[socketName];
-                  if (roomHandler) {
-                    socket.off(socketName, roomHandler);
-                    delete socketRoomHandlersRef.current[socketName];
-                  }
-                  delete newS[socketName];
-                  removeSocketListeners.push(socketName);
-                } else {
-                  newS[socketName].listeners = newS[socketName].listeners + val;
-                }
-              });
-              if (removeSocketListeners.length > 0) {
-                socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
-              }
-              return newS;
-            });
-            setCounterDocuments((prevC) => {
-              const newC = { ...prevC };
-              prevP[id].data.forEach((document) => {
-                if (newC[document] + val <= 0) {
-                  setDocuments((prev2) => {
-                    const newD = { ...prev2 };
-                    delete newD[document];
-                    return newD;
-                  });
-                  delete newC[document];
-                } else {
-                  newC[document] = newC[document] + val;
-                }
-              });
-              return newC;
-            });
-            const newP = { ...prevP };
-            delete newP[id];
-            return newP;
-          });
-          const newProvs = { ...prev };
-          delete newProvs[id];
-          return newProvs;
+        if (!providers[id].dataSource) {
+          const { id: dId, ...rData } = data;
+          const documentId = dId || uuid();
+          const result2 = createDocument({ model: id, documentId, data: rData });
+          return result2;
         }
-      });
-    },
-    [setCounterProviders, setProviders, setCounterDocuments, setDocuments, socket]
-  );
-  const registerProvider = useCallback(
-    async (newItem) => {
-      systemLog("dsp", "[registerProvider]", newItem.id);
-      let result;
-      const { id, ...provider } = newItem;
-      if (providers[id]) {
-        setCounterProviders((prev) => {
-          systemLog("dsp", "[registerProvider] Pouze navysuji ", id, " ", prev[id], " -> ", prev[id] + 1);
-          return {
-            ...prev,
-            [id]: prev[id] + 1
-          };
-        });
-        result = providers[id];
-      } else {
-        const dataFromSource = await getData({
-          schema: newItem.schema,
-          dataSource: newItem.dataSource || {},
-          id: newItem.id,
-          isPersisting: !!newItem.isPersisting && usePersistentStorage,
-          SQLite: SQLite2
+        const result = await postData({
+          dataSource: providers[id].dataSource,
+          schema: providers[id].schema,
+          val: data
         });
-        console.time(`[DSP] VYTVARENI PROVIDERA ${id}`);
-        var dataList = [];
-        var items = {};
-        const dataS = Array.isArray(dataFromSource) ? dataFromSource : [dataFromSource];
-        dataS.forEach((item) => {
-          if (!item) return;
-          const { id: itId, ...data } = item;
-          const id2 = itId || uuid();
-          dataList.push(id2);
-          if (documents[id2]) {
-            items[id2] = {
-              ...documents[id2],
-              ...data
-            };
-          } else {
-            items[id2] = data;
-          }
+        return result;
+      },
+      [providers, createDocument]
+    );
+    const deleteProviderItem = useCallback(
+      async ({ providerId, data, params }) => {
+        if (!providers[providerId]) {
+          systemLog("dsp", "[deleteProviderItem] Provider neexistuje:", providerId);
+          return;
+        }
+        const response = await deleteData({
+          dataSource: renderJSONTemplate(providers[providerId].dataSource, params),
+          // dataSource: providers[providerId].dataSource,
+          data
         });
-        setCounterDocuments((prev) => {
-          {
-            const newC = { ...prev };
-            dataList.forEach((i) => {
-              if (newC[i]) {
-                newC[i] = newC[i] + 1;
+        return response;
+      },
+      [providers]
+    );
+    const registerProviderSockets = useCallback(
+      (sockets2) => {
+        if (sockets2) {
+          systemLog("dsp", "[registerProviderSockets]", sockets2);
+          var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
+          setSockets((prev) => {
+            const newS = { ...prev };
+            d.forEach((item) => {
+              if (newS[item]) {
+                newS[item].listeners = newS[item].listeners + 1;
               } else {
-                newC[i] = 1;
+                const roomHandler = (msg) => {
+                  const { dispatch: currentDispatch, updateDocument: currentUpdateDocument } = socketActionHandlersRef.current;
+                  handleSocketMessage(item, msg, {
+                    dispatch: currentDispatch,
+                    updateDocument: currentUpdateDocument
+                  });
+                };
+                socketRoomHandlersRef.current[item] = roomHandler;
+                newS[item] = { listeners: 1, data: [] };
+                socket.emit("joinRoom", item);
+                socket.on(item, roomHandler);
               }
             });
-            return newC;
+            return newS;
+          });
+        }
+      },
+      [setSockets, socket]
+    );
+    const unregisterProviderSockets = useCallback(
+      (sockets2) => {
+        systemLog("dsp", "[unregisterProviderSockets] Mazu sockety ", JSON.stringify(sockets2, null, 2));
+        var removeSocketListeners = [];
+        var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
+        setSockets((prev) => {
+          const newS = { ...prev };
+          d.forEach((item) => {
+            if (newS[item]?.listeners <= 1) {
+              removeSocketListeners.push(item);
+              const roomHandler = socketRoomHandlersRef.current[item];
+              if (roomHandler) {
+                socket.off(item, roomHandler);
+                delete socketRoomHandlersRef.current[item];
+              }
+              delete newS[item];
+            } else if (newS[item]) newS[item].listeners = newS[item].listeners - 1;
+          });
+          if (removeSocketListeners.length > 0) {
+            socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
           }
+          return newS;
         });
-        if (Object.keys(items).length > 0)
-          setDocuments((prev) => ({ ...prev, ...items }));
-        result = {
-          ...provider,
-          data: dataList,
-          lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
-        };
-        setProviders((prev) => ({
-          ...prev,
-          [id]: result
-        }));
-        setCounterProviders((prev) => ({
-          ...prev,
-          [id]: 1
-        }));
-        dataList;
-        if (provider.dataSource?.socketListeners) registerProviderSockets(provider.dataSource.socketListeners);
-        console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
-      }
-      return result;
-    },
-    [providers, SQLite2, documents, setDocuments, setProviders, setCounterProviders, registerProviderSockets]
-  );
-  const unregisterProvider = useCallback(
-    async (itemId) => {
-      setCounterProviders((prev) => {
-        if (prev[itemId]) {
-          if (prev[itemId] > 1) {
-            systemLog("dsp", "[unregisterProvider] snizuji ", itemId, "z ", prev[itemId], " na ", prev[itemId] - 1);
+      },
+      [setSockets, socket]
+    );
+    const updateProviderListeners = useCallback(
+      async (id, val) => {
+        systemLog("dsp", `[updateProviderListeners] provider:`, id, "menim o", val);
+        setCounterProviders((prev) => {
+          if (!prev[id]) return prev;
+          if (prev[id] + val > 0) {
             return {
               ...prev,
-              [itemId]: prev[itemId] - 1
+              [id]: prev[id] + val
             };
           } else {
-            systemLog("dsp", "[unregisterProvider]  mazu ", Object.keys(providers));
-            unregisterProviderSockets(providers[itemId]?.dataSource.socketListeners);
-            systemLog("dsp", "[unregisterProvider] Mazu dokumenty providera ", itemId);
-            setCounterDocuments((cd) => {
-              const newC = { ...cd };
-              const deleteDocumentIds = [];
-              providers[itemId].data.forEach((docId) => {
-                if (newC[docId] <= 1) {
-                  deleteDocumentIds.push(docId);
-                  delete newC[docId];
-                } else newC[docId] = newC[docId] - 1;
+            setProviders((prevP) => {
+              systemLog("dsp", "[DSP] UPDATE PROVIDER - mazu sockets ", id);
+              setSockets((prevS) => {
+                var removeSocketListeners = [];
+                const newS = { ...prevS };
+                const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
+                providerSocketListeners.forEach((socketName) => {
+                  if (!newS[socketName]) return;
+                  if (newS[socketName].listeners + val <= 0) {
+                    const roomHandler = socketRoomHandlersRef.current[socketName];
+                    if (roomHandler) {
+                      socket.off(socketName, roomHandler);
+                      delete socketRoomHandlersRef.current[socketName];
+                    }
+                    delete newS[socketName];
+                    removeSocketListeners.push(socketName);
+                  } else {
+                    newS[socketName].listeners = newS[socketName].listeners + val;
+                  }
+                });
+                if (removeSocketListeners.length > 0) {
+                  socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
+                }
+                return newS;
               });
-              if (deleteDocumentIds.length > 0) {
-                setDocuments((pd) => {
-                  const newD = { ...pd };
-                  deleteDocumentIds.forEach((docId) => {
-                    delete newD[docId];
-                  });
-                  return newD;
+              setCounterDocuments((prevC) => {
+                const newC = { ...prevC };
+                prevP[id].data.forEach((document) => {
+                  if (newC[document] + val <= 0) {
+                    setDocuments((prev2) => {
+                      const newD = { ...prev2 };
+                      delete newD[document];
+                      return newD;
+                    });
+                    delete newC[document];
+                  } else {
+                    newC[document] = newC[document] + val;
+                  }
                 });
-              }
-              return newC;
-            });
-            setProviders((pp) => {
-              const newProvs2 = { ...pp };
-              delete newProvs2[itemId];
-              return newProvs2;
+                return newC;
+              });
+              const newP = { ...prevP };
+              delete newP[id];
+              return newP;
             });
             const newProvs = { ...prev };
-            delete newProvs[itemId];
+            delete newProvs[id];
             return newProvs;
           }
-        } else return prev;
-      });
-    },
-    [setCounterProviders, providers, setCounterDocuments, setDocuments, setProviders, unregisterProviderSockets]
-  );
-  const actionsValue = useMemo(
-    () => ({
-      dispatch,
-      initProvider,
-      resetProvider,
-      registerProvider,
-      unregisterProvider,
-      updateProviderListeners,
-      resetDataStore,
-      startSockets,
-      stopSockets,
-      registerProviderSockets,
-      unregisterProviderSockets,
-      updateDocuments,
-      presetProviders
-    }),
-    [
-      dispatch,
-      initProvider,
-      resetProvider,
-      registerProvider,
-      unregisterProvider,
-      updateProviderListeners,
-      resetDataStore,
-      startSockets,
-      stopSockets,
-      registerProviderSockets,
-      unregisterProviderSockets,
-      updateDocuments,
-      presetProviders
-    ]
-  );
-  const metaValue = useMemo(
-    () => ({ isLive, isSynchronizing, sockets, counterProviders, counterDocuments }),
-    [isLive, isSynchronizing, sockets, counterProviders, counterDocuments]
-  );
-  const stableValue = useMemo(
-    () => ({
-      dispatch,
-      presetProviders,
-      updateProviderListeners,
-      subscribeToProvider,
-      getProviderLastUpdate,
-      getExternalDocuments,
-      getExternalProviders
-    }),
-    [
-      dispatch,
-      presetProviders,
-      updateProviderListeners,
-      subscribeToProvider,
-      getProviderLastUpdate,
-      getExternalDocuments,
-      getExternalProviders
-    ]
-  );
-  systemLog("dsp", "END");
-  return (
-    // <DatabaseProvider>
-    /* @__PURE__ */ jsx(DataStoreStableContext.Provider, { value: stableValue, children: /* @__PURE__ */ jsx(DataStoreActionsContext.Provider, { value: actionsValue, children: /* @__PURE__ */ jsx(DataStoreProvidersContext.Provider, { value: providers, children: /* @__PURE__ */ jsx(DataStoreDocumentsContext.Provider, { value: documents, children: /* @__PURE__ */ jsx(DataStoreContext.Provider, { value: metaValue, children: props.children }) }) }) }) })
-  );
-};
+        });
+      },
+      [setCounterProviders, setProviders, setCounterDocuments, setDocuments, socket]
+    );
+    const registerProvider = useCallback(
+      async (newItem) => {
+        systemLog("dsp", "[registerProvider]", newItem.id);
+        let result;
+        const { id, ...provider } = newItem;
+        if (providers[id]) {
+          setCounterProviders((prev) => {
+            systemLog("dsp", "[registerProvider] Pouze navysuji ", id, " ", prev[id], " -> ", prev[id] + 1);
+            return {
+              ...prev,
+              [id]: prev[id] + 1
+            };
+          });
+          result = providers[id];
+        } else {
+          try {
+            const dataFromSource = await getData({
+              schema: newItem.schema,
+              dataSource: newItem.dataSource || {},
+              id: newItem.id,
+              isPersisting: !!newItem.isPersisting && !!persistenceStorage,
+              SQLite: persistenceStorage || void 0
+            });
+            console.time(`[DSP] VYTVARENI PROVIDERA ${id}`);
+            var dataList = [];
+            var items = {};
+            const dataS = Array.isArray(dataFromSource) ? dataFromSource : [dataFromSource];
+            dataS.forEach((item) => {
+              if (!item) return;
+              const { id: itId, ...data } = item;
+              const normalizedId = itId || uuid();
+              dataList.push(normalizedId);
+              if (documents[normalizedId]) {
+                items[normalizedId] = {
+                  ...documents[normalizedId],
+                  ...data
+                };
+              } else {
+                items[normalizedId] = data;
+              }
+            });
+            setCounterDocuments((prev) => {
+              const newC = { ...prev };
+              dataList.forEach((itemId) => {
+                if (newC[itemId]) {
+                  newC[itemId] = newC[itemId] + 1;
+                } else {
+                  newC[itemId] = 1;
+                }
+              });
+              return newC;
+            });
+            if (Object.keys(items).length > 0) {
+              setDocuments((prev) => ({ ...prev, ...items }));
+            }
+            result = {
+              ...provider,
+              data: dataList,
+              lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
+            };
+            setProviders((prev) => ({
+              ...prev,
+              [id]: result
+            }));
+            setCounterProviders((prev) => ({
+              ...prev,
+              [id]: 1
+            }));
+            if (provider.dataSource?.socketListeners) {
+              registerProviderSockets(provider.dataSource.socketListeners);
+            }
+            console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
+          } catch (error) {
+            console.error("[DataStoreProvider] registerProvider:error", { id: newItem.id, error });
+            throw error;
+          }
+        }
+        return result;
+      },
+      [providers, documents, setDocuments, setProviders, setCounterProviders, registerProviderSockets, persistenceStorage]
+    );
+    const unregisterProvider = useCallback(
+      async (itemId) => {
+        setCounterProviders((prev) => {
+          if (prev[itemId]) {
+            if (prev[itemId] > 1) {
+              systemLog("dsp", "[unregisterProvider] snizuji ", itemId, "z ", prev[itemId], " na ", prev[itemId] - 1);
+              return {
+                ...prev,
+                [itemId]: prev[itemId] - 1
+              };
+            } else {
+              systemLog("dsp", "[unregisterProvider]  mazu ", Object.keys(providers));
+              unregisterProviderSockets(providers[itemId]?.dataSource.socketListeners);
+              systemLog("dsp", "[unregisterProvider] Mazu dokumenty providera ", itemId);
+              setCounterDocuments((cd) => {
+                const newC = { ...cd };
+                const deleteDocumentIds = [];
+                providers[itemId].data.forEach((docId) => {
+                  if (newC[docId] <= 1) {
+                    deleteDocumentIds.push(docId);
+                    delete newC[docId];
+                  } else newC[docId] = newC[docId] - 1;
+                });
+                if (deleteDocumentIds.length > 0) {
+                  setDocuments((pd) => {
+                    const newD = { ...pd };
+                    deleteDocumentIds.forEach((docId) => {
+                      delete newD[docId];
+                    });
+                    return newD;
+                  });
+                }
+                return newC;
+              });
+              setProviders((pp) => {
+                const newProvs2 = { ...pp };
+                delete newProvs2[itemId];
+                return newProvs2;
+              });
+              const newProvs = { ...prev };
+              delete newProvs[itemId];
+              return newProvs;
+            }
+          } else return prev;
+        });
+      },
+      [setCounterProviders, providers, setCounterDocuments, setDocuments, setProviders, unregisterProviderSockets]
+    );
+    const actionsValue = useMemo(
+      () => ({
+        dispatch,
+        initProvider,
+        resetProvider,
+        registerProvider,
+        unregisterProvider,
+        updateProviderListeners,
+        resetDataStore,
+        startSockets,
+        stopSockets,
+        registerProviderSockets,
+        unregisterProviderSockets,
+        updateDocuments,
+        presetProviders
+      }),
+      [
+        dispatch,
+        initProvider,
+        resetProvider,
+        registerProvider,
+        unregisterProvider,
+        updateProviderListeners,
+        resetDataStore,
+        startSockets,
+        stopSockets,
+        registerProviderSockets,
+        unregisterProviderSockets,
+        updateDocuments,
+        presetProviders
+      ]
+    );
+    const metaValue = useMemo(
+      () => ({ isLive, isSynchronizing, sockets, counterProviders, counterDocuments }),
+      [isLive, isSynchronizing, sockets, counterProviders, counterDocuments]
+    );
+    const stableValue = useMemo(
+      () => ({
+        dispatch,
+        presetProviders,
+        updateProviderListeners,
+        subscribeToProvider,
+        getProviderLastUpdate,
+        getExternalDocuments,
+        getExternalProviders
+      }),
+      [
+        dispatch,
+        presetProviders,
+        updateProviderListeners,
+        subscribeToProvider,
+        getProviderLastUpdate,
+        getExternalDocuments,
+        getExternalProviders
+      ]
+    );
+    useImperativeHandle(ref, () => actionsValue, [actionsValue]);
+    systemLog("dsp", "END");
+    return (
+      // <DatabaseProvider>
+      /* @__PURE__ */ jsx(DataStoreStableContext.Provider, { value: stableValue, children: /* @__PURE__ */ jsx(DataStoreActionsContext.Provider, { value: actionsValue, children: /* @__PURE__ */ jsx(DataStoreProvidersContext.Provider, { value: providers, children: /* @__PURE__ */ jsx(DataStoreDocumentsContext.Provider, { value: documents, children: /* @__PURE__ */ jsx(DataStoreContext.Provider, { value: metaValue, children: props.children }) }) }) }) })
+    );
+  }
+);
 var DataStoreProvider_default = DataStoreProvider;
 
 // src/useDataProvider.tsx
@@ -2266,7 +2171,6 @@ export {
   DataStoreProvider_default as DataStoreProvider,
   DataStoreProvidersContext,
   DataStoreStableContext,
-  SQLite2 as SQLite,
   dataStoreFilterObject,
   doesObjectMatchFilter,
   doesValueMatchFilter,