@mgarlik/datastore 0.1.1 → 0.1.3

package/dist/index.js

@@ -3,29 +3,45 @@ import {
 } from "./chunk-7XDRKNJQ.js";
 
 // src/DataStoreProvider.tsx
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
 
 // src/handleSocketMessage.ts
-var handleSocketMessage = (model, msg, dataProvider) => {
-  const { dispatch, updateDocument } = dataProvider;
+var handleSocketMessage = (msg, dataProvider) => {
+  const { dispatch } = dataProvider;
+  console.log("Mam socket message, data: ", msg);
   const data = JSON.parse(msg);
   switch (data.action) {
     case "create":
       systemLog("sockets", "[create] ", data.model, ", document: ", data.documentId);
+      console.log("[SOCKETS] CREATING model:", data.model, ", document: ", data.documentId, " data:", data.data);
       dispatch?.("createDocument", { model: data.model, documentId: data.documentId, data: data.data });
       break;
     case "update":
+      console.log(`[SOCKETS] UPDATE model: ${data.model}, document: ${data.documentId}, data: `, data.data);
       systemLog("sockets", `[update] ${JSON.stringify(data)}`);
       if (Array.isArray(data.data)) dispatch?.("updateDocuments", { model: data.model, documents: data.data });
-      else updateDocument?.({ model: data.model, documentId: data.documentId, data: data.data });
+      else {
+        dispatch?.("updateDocument", { model: data.model, documentId: data.documentId, data: data.data });
+      }
       break;
     case "delete":
+      console.log(`[SOCKETS] DELETE model: ${data.model}, document: ${data.documentId}`);
       systemLog("sockets", "[delete] model:", data.model, ", document: ", data.documentId);
-      dispatch?.("deleteDocument", { documentId: data.documentId, data: data.data });
+      dispatch?.("deleteDocument", { model: data.model, documentId: data.documentId, data: data.data });
       break;
     case "deleteItem":
-      systemLog("sockets", "DELETE ITEM ", model, ", model: ", data.model, ", data: ", data.data);
-      dispatch?.("removeItem", { model, documentId: data.data.id });
+      systemLog("sockets", "DELETE ITEM ", data.model, ", model: ", data.model, ", data: ", data.data);
+      dispatch?.("removeItem", { model: data.model, documentId: data.data.id });
       break;
     default:
       console.error(`Unknown command ${data.action}`);
@@ -433,12 +449,15 @@ function doesValueMatchFilter(objVal, value, documents = {}) {
   }
 }
 function doesObjectMatchFilter(obj, filter, documents = {}) {
+  console.log("doesObjectMatchFilter", "Obj", JSON.stringify(obj, null, 2), "Filter", JSON.stringify(filter, null, 2));
   if (!filter) return true;
   if (Object.keys(filter)?.includes("$rule")) {
+    console.log("Pravidloo: ", filter.$rule);
     const result2 = doesObjectMatchFilter(obj, filter.$rule, documents);
     if (result2 === true) {
       return result2;
     } else {
+      console.log("Vracim chybovou message ", filter.$message);
       return filter.$message || false;
     }
   }
@@ -587,11 +606,20 @@ var saveData = async ({
   }
   console.timeEnd(`[SQL] saveData ${providerId}`);
 };
+var serializeParams = (params) => {
+  return Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [
+      key,
+      typeof value === "object" ? JSON.stringify(value) : value
+    ])
+  );
+};
 var buildUri = ({
   method,
   dataSource,
   variant
 }) => {
+  console.log("[HANDLE DATA] BUILD URI method ", method, " from", dataSource);
   if (dataSource.crud) {
     if (method === "update" && dataSource.crud.updates) {
       if (variant && dataSource.crud.updates[variant]) return dataSource.crud.updates[variant];
@@ -625,7 +653,7 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime
         console.time("Persisted Data");
         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;
+        if (qDatum[0]?.lastUpdate) params.changeTimeFrom = qDatum[0].lastUpdate;
         persistedData = qDatum.map((item) => {
           try {
             const parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
@@ -642,8 +670,8 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime
         console.timeEnd("Persisted Data");
       }
       if (dataSource) {
-        systemLog("axios", "Params: ", JSON.stringify(params));
-        const axiosResponse = await axios.get(buildUri({ dataSource, method: "read" }), { params });
+        console.log("Stahuji data z ", buildUri({ dataSource, method: "read" }), " s parametry ", params);
+        const axiosResponse = await axios.get(buildUri({ dataSource, method: "read" }), { params: serializeParams(params) });
         if (schema && !dataSource.readAllFields) {
           if (Array.isArray(axiosResponse.data.data)) {
             newData = [];
@@ -878,796 +906,839 @@ var resolveLocale = () => {
   }
   return void 0;
 };
-var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true, locale, storage = null, ...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);
-  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;
-    }
-    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));
+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;
+      }
+      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");
         }
-      } finally {
-        systemLog("dsp", "[INIT] Axios check done");
       }
-    }
-    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());
+      checkServer();
+    }, [locale, restServer]);
+    useEffect(() => {
+      if (usePersistentStorage && !storage) {
+        systemLog("dsp", "[INIT] Persistence is enabled but no storage adapter was provided.");
       }
-    });
-    Object.keys(previousProviderUpdateIdsRef.current).forEach((providerId) => {
-      if (!(providerId in currentUpdateIds)) {
-        const subscribers = providerSubscribersRef.current.get(providerId);
-        subscribers?.forEach((callback) => callback());
+    }, [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}`;
       }
-    });
-    previousProviderUpdateIdsRef.current = currentUpdateIds;
-  }, [providers]);
-  useEffect(() => {
-    externalDocumentsRef.current = documents;
-  }, [documents]);
-  const persistDocument = useCallback(
-    async ({
-      documentId,
-      model,
-      data,
-      lastUpdate = (/* @__PURE__ */ new Date()).toISOString()
-    }) => {
-      if (!persistenceStorage) return;
-      await persistenceStorage.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
+      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
-      ]);
-    },
-    [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
-          });
-          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 roomsToJoin = Object.entries(sockets).flatMap(
+          ([roomName, socketItem]) => socketItem.filters.map(({ filter }) => ({ room: roomName, filter }))
+        );
+        console.log("Sokety pro p\u0159ipojen\xED:", roomsToJoin);
+        systemLog("dsp", "useEffect[isLive] registruji", roomsToJoin);
+        if (roomsToJoin.length > 0) socket.emit("joinRooms", roomsToJoin);
+        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 (persistenceStorage?.emptyTable) {
-      await persistenceStorage.emptyTable("documents");
-    }
-    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);
+    }, [isLive, socket, sockets, synchronizeDataStore]);
+    const presetProviders = props.providers;
+    useEffect(() => {
+      socket.on("connect", handleSocketConnect);
+      socket.on("disconnect", handleSocketDisconnect);
+      if (socketServer?.params?.socketEvents && socketServer.params.socketEvents.length > 0) {
+        socketServer?.params?.socketEvents?.map(
+          (event) => socket.on(event, (data) => handleSocketMessage(data, socketActionHandlersRef.current))
+        );
+      } else {
+        socket.on("create", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
+        socket.on("update", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
+        socket.on("delete", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
       }
-      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}`);
+      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");
       }
-    }
-    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;
+      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":
+              console.log("Dispatcher createDocument", item.data);
+              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}`);
+        }
       }
-      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 && persistenceStorage) {
-        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, 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;
+      },
+      [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 && persistenceStorage) {
-          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, persistenceStorage]
-  );
-  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 && persistenceStorage) {
-          await persistDocument({ documentId, model, data: newDocument });
+        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 {
+            systemLog("dsp", "[updateDataStore] Updatuje Socket");
+          }
         }
+        return result;
+      },
+      [providers, documents, isLive, updateDocument]
+    );
+    useEffect(() => {
+      socketActionHandlersRef.current = { dispatch, updateDocument };
+    }, [dispatch, updateDocument]);
+    const createDocument = useCallback(
+      async ({ model, documentId, data }) => {
+        const newDocument = data;
+        console.log(`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))) {
+            if (!provider.data.includes(documentId)) {
+              setCounterDocuments((prev) => {
+                const newC = { ...prev };
+                if (newC[documentId]) {
+                  setDocuments((prev2) => ({
+                    ...prev2,
+                    [documentId]: { ...prev2[documentId], ...newDocument }
+                  }));
+                  newC[documentId] = prev[documentId] + 1;
+                } else {
+                  setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
+                  newC[documentId] = providerListenersCount;
+                }
+                return newC;
+              });
+              providerListenersCount++;
+              setProviders((prev) => ({
+                ...prev,
+                [key]: {
+                  ...prev[key],
+                  data: [...prev[key].data, documentId],
+                  lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
+                }
+              }));
+            }
+          }
+        });
+        console.log("Provider listeners count: ", providerListenersCount);
+        if (providerListenersCount > 0) {
+          if (providers[model]?.isPersisting && persistenceStorage) {
+            console.log("Persistuji dokument ", documentId, " do modelu ", model);
+            await persistDocument({ documentId, model, data: newDocument });
+          }
+          console.log("Dokument ", documentId, " zaregistrovan do ", providerListenersCount, " provideru");
+          console.log(newDocument);
+          return { id: documentId, document: newDocument };
+        } else return false;
+      },
+      [providers, setProviders, setCounterDocuments, setDocuments, persistDocument, persistenceStorage]
+    );
+    const deleteDocument = useCallback(
+      async ({ documentId }) => {
+        console.log("Mazani dokumentu ", 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 };
-          if (newC[documentId]) {
-            setDocuments((prev2) => ({
-              ...prev2,
-              [documentId]: { ...prev2[documentId], ...newDocument }
-            }));
-            newC[documentId] = prev[documentId] + providerListenersCount;
-          } else {
-            setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
-            newC[documentId] = providerListenersCount;
-          }
+          delete newC[documentId];
           return newC;
         });
-        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;
-      });
-      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);
+        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;
         }
-        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];
+        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, filter) => {
+        if (!sockets2) return;
+        const normalizedFilter = filter ?? {};
+        systemLog("dsp", "[registerProviderSockets]", sockets2, `filter: ${JSON.stringify(normalizedFilter)}`);
+        const d = Array.isArray(sockets2) ? sockets2 : [sockets2];
         setSockets((prev) => {
           const newS = { ...prev };
           d.forEach((item) => {
             if (newS[item]) {
-              newS[item].listeners = newS[item].listeners + 1;
+              const existingFilter = newS[item].filters.find((f) => isEqual(f.filter, normalizedFilter));
+              if (existingFilter) {
+                existingFilter.listeners++;
+                systemLog("dsp", `[registerProviderSockets] Filter uz existuje, navysuji listeners na ${existingFilter.listeners}`);
+              } else {
+                newS[item].filters = [...newS[item].filters, { filter: normalizedFilter, listeners: 1 }];
+                socket.emit("joinRoom", { room: item, filter: normalizedFilter });
+                systemLog(
+                  "dsp",
+                  `[registerProviderSockets] Novy filter, registruji room ${item} s filterem ${JSON.stringify(normalizedFilter)}`
+                );
+              }
             } else {
-              const roomHandler = (msg) => {
-                const { dispatch: currentDispatch, updateDocument: currentUpdateDocument } = socketActionHandlersRef.current;
-                handleSocketMessage(item, msg, {
-                  dispatch: currentDispatch,
-                  updateDocument: currentUpdateDocument
-                });
+              newS[item] = {
+                filters: [{ filter: normalizedFilter, listeners: 1 }],
+                data: []
               };
-              socketRoomHandlersRef.current[item] = roomHandler;
-              newS[item] = { listeners: 1, data: [] };
-              socket.emit("joinRoom", item);
-              socket.on(item, roomHandler);
+              socket.emit("joinRoom", { room: item, filter: normalizedFilter });
+              systemLog("dsp", `[registerProviderSockets] Nova room ${item}, filter: ${JSON.stringify(normalizedFilter)}`);
             }
           });
           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];
+      },
+      [setSockets, socket]
+    );
+    const unregisterProviderSockets = useCallback(
+      (sockets2, filter) => {
+        const normalizedFilter = filter ?? {};
+        systemLog(
+          "dsp",
+          "[unregisterProviderSockets] Mazu sockety",
+          JSON.stringify(sockets2, null, 2),
+          `filter: ${JSON.stringify(normalizedFilter)}`
+        );
+        const d = Array.isArray(sockets2) ? sockets2 : [sockets2];
+        setSockets((prev) => {
+          const newS = { ...prev };
+          const removeSocketListeners = [];
+          d.forEach((item) => {
+            if (!newS[item]) return;
+            const existingFilter = newS[item].filters.find((f) => isEqual(f.filter, normalizedFilter));
+            if (!existingFilter) return;
+            if (existingFilter.listeners <= 1) {
+              newS[item].filters = newS[item].filters.filter((f) => !isEqual(f.filter, normalizedFilter));
+              socket.emit("leaveRoom", { room: item, filter: normalizedFilter });
+              systemLog(
+                "dsp",
+                `[unregisterProviderSockets] Filter smazan, odhlaseni room ${item} s filterem ${JSON.stringify(normalizedFilter)}`
+              );
+            } else {
+              existingFilter.listeners--;
+              systemLog("dsp", `[unregisterProviderSockets] Filter listeners snizen na ${existingFilter.listeners}`);
             }
-            delete newS[item];
-          } else if (newS[item]) newS[item].listeners = newS[item].listeners - 1;
+            if (newS[item].filters.length === 0) {
+              removeSocketListeners.push(item);
+              delete newS[item];
+              systemLog("dsp", `[unregisterProviderSockets] Room ${item} uplne smazana`);
+            }
+          });
+          if (removeSocketListeners.length > 0) {
+            socket.emit("leaveRooms", removeSocketListeners);
+          }
+          return newS;
         });
-        if (removeSocketListeners.length > 0) {
-          socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
-        }
-        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 {
+      },
+      [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 };
+          }
           setProviders((prevP) => {
             systemLog("dsp", "[DSP] UPDATE PROVIDER - mazu sockets ", id);
             setSockets((prevS) => {
-              var removeSocketListeners = [];
               const newS = { ...prevS };
+              const removeSocketListeners = [];
               const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
+              const providerFilter = prevP[id].dataSource?.filter;
+              const normalizedFilter = providerFilter ?? {};
               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);
+                const existingFilter = newS[socketName].filters.find((f) => isEqual(f.filter, normalizedFilter));
+                if (!existingFilter) return;
+                if (existingFilter.listeners + val <= 0) {
+                  newS[socketName].filters = newS[socketName].filters.filter((f) => !isEqual(f.filter, normalizedFilter));
+                  socket.emit("leaveRoom", { room: socketName, filter: normalizedFilter });
+                  systemLog("dsp", `[updateProviderListeners] Filter smazan pro room ${socketName}`);
                 } else {
-                  newS[socketName].listeners = newS[socketName].listeners + val;
+                  existingFilter.listeners = existingFilter.listeners + val;
+                  systemLog("dsp", `[updateProviderListeners] Filter listeners snizen na ${existingFilter.listeners}`);
+                }
+                if (newS[socketName].filters.length === 0) {
+                  removeSocketListeners.push(socketName);
+                  delete newS[socketName];
+                  systemLog("dsp", `[updateProviderListeners] Room ${socketName} uplne smazana`);
                 }
               });
               if (removeSocketListeners.length > 0) {
-                socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
+                socket.emit("leaveRooms", removeSocketListeners);
               }
               return newS;
             });
@@ -1694,202 +1765,203 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
           const newProvs = { ...prev };
           delete newProvs[id];
           return newProvs;
-        }
-      });
-    },
-    [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;
-            }
+      },
+      [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
+            };
           });
-          setCounterDocuments((prev) => {
-            const newC = { ...prev };
-            dataList.forEach((itemId) => {
-              if (newC[itemId]) {
-                newC[itemId] = newC[itemId] + 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 {
-                newC[itemId] = 1;
+                items[normalizedId] = data;
               }
             });
-            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;
+            setCounterDocuments((prev) => {
+              const newC = { ...prev };
+              dataList.forEach((itemId) => {
+                if (newC[itemId]) {
+                  newC[itemId] = newC[itemId] + 1;
+                } else {
+                  newC[itemId] = 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;
+            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, provider.dataSource.filter);
+            }
+            console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
+          } catch (error) {
+            console.error("[DataStoreProvider] registerProvider:error", { id: newItem.id, error });
+            throw error;
           }
-        } 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 }) }) }) }) })
-  );
-};
+        }
+        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, providers[itemId]?.dataSource.filter);
+              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