@mgarlik/datastore 0.1.0

package/dist/index.js

@@ -0,0 +1,2289 @@
+// src/DataStoreProvider.tsx
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+
+// src/log.ts
+function systemLog(..._args) {
+}
+function systemLogError(...args) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(...args);
+  }
+}
+
+// src/handleSocketMessage.ts
+var handleSocketMessage = (model, msg, dataProvider) => {
+  const { dispatch, updateDocument } = dataProvider;
+  const data = JSON.parse(msg);
+  switch (data.action) {
+    case "create":
+      systemLog("sockets", "[create] ", data.model, ", document: ", data.documentId);
+      dispatch?.("createDocument", { model: data.model, documentId: data.documentId, data: data.data });
+      break;
+    case "update":
+      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 });
+      break;
+    case "delete":
+      systemLog("sockets", "[delete] model:", data.model, ", document: ", data.documentId);
+      dispatch?.("deleteDocument", { 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 });
+      break;
+    default:
+      console.error(`Unknown command ${data.action}`);
+  }
+};
+
+// 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) => {
+    const last = index > 0 && list[index - 1];
+    if (last && /(?:^|[^\\])\\$/.test(last)) {
+      const prev = ret.pop() || "";
+      ret.push(prev.slice(0, -1) + "." + el);
+    } else {
+      ret.push(el);
+    }
+    return ret;
+  }, []);
+}
+function getValueByDotPath(obj, prop, value) {
+  prop = typeof prop === "number" ? propToArray(prop.toString()) : typeof prop === "string" ? propToArray(prop) : prop;
+  let currentObj = obj;
+  for (let i = 0; i < (prop?.length || 0); i += 1) {
+    if (currentObj === null || typeof currentObj !== "object") {
+      return value;
+    }
+    let head = prop[i];
+    if (Array.isArray(currentObj)) {
+      const results = [];
+      for (let j = 0; j < currentObj.length; j += 1) {
+        const result = getValueByDotPath(currentObj[j], prop.slice(i), value);
+        if (result !== value) {
+          results.push(result);
+        }
+      }
+      return results.flat();
+    }
+    if (head === "$end" && Array.isArray(currentObj)) {
+      head = currentObj.length - 1;
+    }
+    currentObj = currentObj[head];
+  }
+  if (typeof currentObj === "undefined") {
+    return value;
+  }
+  return currentObj;
+}
+
+// src/utils.ts
+import dayjs from "dayjs";
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function recalculateObjectWithDocument(obj, document) {
+  if (obj === void 0) return;
+  if (Array.isArray(obj)) {
+    const results = [];
+    obj.forEach((item) => {
+      const result = recalculateObjectWithDocument(item, document);
+      if (result !== void 0) {
+        results.push(result);
+      }
+    });
+    return results;
+  } else if (typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.some((item) => item.startsWith("$"))) {
+      if (keys.includes("$rule")) {
+        const res = doesObjectMatchFilter(document, obj["$rule"]);
+        if (res && obj["$value"] !== void 0) {
+          return recalculateObjectWithDocument(obj["$value"], document);
+        } else if (obj["$value"] === void 0) {
+          return res;
+        }
+      } else if (keys.includes("$or")) {
+        return obj["$or"].some((condition) => {
+          const res = doesObjectMatchFilter(document, condition);
+          if (typeof res === "boolean") return res;
+          const error = res;
+          return false;
+        });
+      } else if (keys.includes("$and")) {
+        return obj["$and"].every((condition) => {
+          const res = doesObjectMatchFilter(document, condition);
+          if (typeof res === "boolean") return res;
+          const error = res;
+          return false;
+        });
+      } else if (keys.includes("$min")) {
+        const res = recalculateObjectWithDocument(obj["$min"], document);
+        if (res.length === 0) return void 0;
+        return Math.min(...res);
+      } else if (keys.includes("$max")) {
+        const res = recalculateObjectWithDocument(obj["$max"], document);
+        if (res.length === 0) return void 0;
+        return Math.max(...res);
+      } else if (keys.includes("$sum")) {
+        const res = recalculateObjectWithDocument(obj["$sum"], document);
+        if (res) return res.reduce((acc, val) => acc + val, 0);
+        else return void 0;
+      } else if (keys.includes("$avg")) {
+        const res = recalculateObjectWithDocument(obj["$avg"], document);
+        const sum = res.reduce((acc, val) => acc + val, 0);
+        return sum / res.length;
+      } else if (keys.includes("$median")) {
+        const res = recalculateObjectWithDocument(obj["$median"], document);
+        const sortedArray = res.slice().sort((a, b) => a - b);
+        let median;
+        const middleIndex = Math.floor(sortedArray.length / 2);
+        if (sortedArray.length % 2 === 0) {
+          median = (sortedArray[middleIndex - 1] + sortedArray[middleIndex]) / 2;
+        } else {
+          median = sortedArray[middleIndex];
+        }
+        return median;
+      } else if (keys.includes("$val") || keys.includes("$value")) {
+        const res = recalculateObjectWithDocument(obj["$val"] || obj["$value"], document);
+        if (res.length === 1) return res[0];
+        return res;
+      } else if (keys.includes("$first")) {
+        const res = recalculateObjectWithDocument(obj["$first"], document);
+        return res?.[0];
+      } else if (keys.includes("$last")) {
+        const res = recalculateObjectWithDocument(obj["$last"], document);
+        return res?.[res.length - 1];
+      } else if (keys.includes("$concat")) {
+        const res = recalculateObjectWithDocument(obj["$concat"], document);
+        return res.join("");
+      } else if (keys.includes("$plus")) {
+        const res = recalculateObjectWithDocument(obj["$plus"], document);
+        return res.reduce((accumulator, currentValue) => accumulator + Number(currentValue), 0);
+      } else if (keys.includes("$minus")) {
+        const res = recalculateObjectWithDocument(obj["$minus"], document);
+        if (res?.length > 0) {
+          const first = res.shift();
+          return res.reduce((accumulator, currentValue) => accumulator - Number(currentValue), first);
+        }
+        return res;
+      } else if (keys.includes("$times")) {
+        const res = recalculateObjectWithDocument(obj["$times"], document);
+        return res.reduce((accumulator, currentValue) => accumulator * Number(currentValue), 1);
+      } else if (keys.includes("$div") || keys.includes("$divide")) {
+        const res = recalculateObjectWithDocument(obj["$div"] || obj["$divide"], document);
+        const first = res.shift();
+        return res.reduce((accumulator, currentValue) => accumulator / Number(currentValue), first);
+      } else if (keys.includes("$mod")) {
+        const res = recalculateObjectWithDocument(obj["$mod"], document);
+        return res[0] % res[1];
+      } else if (keys.includes("$round")) {
+        const res = recalculateObjectWithDocument(obj["$round"], document);
+        if (Array.isArray(res)) {
+          const decimals = res[1] || 0;
+          return Math.round(res[0] * Math.pow(10, decimals)) / Math.pow(10, decimals);
+        }
+        return Math.round(res);
+      } else if (keys.includes("$ceil")) {
+        const res = recalculateObjectWithDocument(obj["$ceil"], document);
+        if (Array.isArray(res)) {
+          const decimals = res[1] || 0;
+          return Math.ceil(res[0] * Math.pow(10, decimals)) / Math.pow(10, decimals);
+        }
+        return Math.floor(res);
+      } else if (keys.includes("$floor")) {
+        const res = recalculateObjectWithDocument(obj["$floor"], document);
+        return Math.floor(res);
+      } else if (keys.includes("$gt")) {
+        const res = recalculateObjectWithDocument(obj["$gt"], document);
+        return res[0] > res[1];
+      } else if (keys.includes("$gte")) {
+        const res = recalculateObjectWithDocument(obj["$gte"], document);
+        return res[0] >= res[1];
+      } else if (keys.includes("$lt")) {
+        const res = recalculateObjectWithDocument(obj["$lt"], document);
+        return res[0] < res[1];
+      } else if (keys.includes("$lte")) {
+        const res = recalculateObjectWithDocument(obj["$lte"], document);
+        return res[0] <= res[1];
+      } else if (keys.includes("$eq")) {
+        const res = recalculateObjectWithDocument(obj["$eq"], document);
+        return res[0] === res[1];
+      } else if (keys.includes("$neq")) {
+        const res = recalculateObjectWithDocument(obj["$neq"], document);
+        return res[0] !== res[1];
+      } else {
+        let data = getValueByDotPath(document, Object.keys(obj)[0].substring(1));
+        if (typeof obj === "object") {
+          data = getObjectValue(data, obj[Object.keys(obj)[0]], document);
+        }
+        return data;
+      }
+    } else {
+      const result = {};
+      keys.forEach((key) => result[key] = recalculateObjectWithDocument(getValueByDotPath(obj[key]), document));
+      return result;
+    }
+  } else {
+    if (typeof obj === "string" && obj.startsWith("$")) return getValueByDotPath(document, obj.substring(1));
+    else return obj;
+  }
+}
+function getObjectValue(ddd, obj, documents) {
+  const data = Array.isArray(ddd) ? ddd.length > 0 ? [...ddd] : void 0 : typeof ddd === "object" ? Object.keys(ddd).length > 0 ? { ...ddd } : void 0 : ddd;
+  if (!data) return void 0;
+  switch (Object.keys(obj)[0]) {
+    case "$pipe":
+      let result = data;
+      for (const action of obj.$pipe) {
+        if (result) result = getObjectValue(result, action, documents);
+      }
+      return result;
+    case "$filter":
+      const filterRes = data.map((d) => {
+        if (typeof d === "object") {
+          if (doesObjectMatchFilter(d, obj.$filter, documents)) return d;
+        } else {
+          if (doesValueMatchFilter(d, obj.$filter, documents)) return d;
+        }
+      }).filter((u) => u);
+      return filterRes;
+    case "$sort":
+      console.log("Sorting", obj.$sort);
+      if (typeof obj.$sort === "object") {
+        const rr = data.sortBy(obj.$sort);
+        return rr;
+      } else return obj.$sort === "ASC" ? data.sort((a, b) => a - b) : data.sort((a, b) => b - a);
+    case "$limit":
+      let limit = Array.isArray(obj.$limit) ? [...obj.$limit] : [obj.$limit];
+      if (limit.length === 1) limit.unshift(0);
+      else limit[1] = limit[1] + limit[0];
+      const res = data.slice(...limit);
+      return res;
+    case "$project":
+      if (!Array.isArray(obj.$project)) obj.$project = [obj.$project];
+      return data.map((o) => Object.fromEntries(Object.entries(o).filter(([key]) => obj.$project.includes(key))));
+    case "$extract":
+      const sres = data.map((o) => {
+        const res2 = getValueByDotPath(o, obj.$extract);
+        return res2;
+      });
+      return sres.flat();
+    // return sres
+    case "$extractValue":
+      const rv = data.map((o) => o[obj.$extract]);
+      if (rv.length === 1) return rv[0];
+      else return rv;
+    default:
+  }
+  return data;
+}
+function getValueByRules(data, document, { mode, ruleId }) {
+  if (Array.isArray(data)) {
+    const results = [];
+    data.forEach((item) => {
+      const res = getValueByRules(item, document, { mode, ruleId });
+      if (res !== void 0) results.push(res);
+    });
+    switch (mode) {
+      case "min":
+        if (results.length === 0) return void 0;
+        return Math.min(...results);
+      case "max":
+        return Math.max(...results);
+      case "array":
+        return results;
+      case "value":
+      default:
+        if (results.length === 1) return results[0];
+        return results;
+    }
+  }
+  if (typeof data === "object") {
+    if (data._value !== void 0) {
+      if (data._rules) {
+        if (Array.isArray(data._rules)) {
+          if (doesObjectMatchFilter(document, data._rules.find((rule) => rule._id === ruleId)._rules)) {
+            return data._value;
+          }
+        } else if (doesObjectMatchFilter(document, data._rules)) {
+          return data._value;
+        }
+        return void 0;
+      }
+      return data._value;
+    }
+    return data;
+  }
+  return data;
+}
+function doesValueMatchFilter(objVal, value, documents = {}) {
+  if (value === void 0) return true;
+  if (typeof value === "object") {
+    switch (Object.keys(value)[0]) {
+      case "$filter":
+        return doesObjectMatchFilter(
+          objVal.filter((o) => doesObjectMatchFilter(o, value.$filter, documents)),
+          value.$next
+        );
+      case "$or":
+        return value.$or.some((filter) => doesValueMatchFilter(objVal, filter));
+      case "$and":
+        return value.$and.every((filter) => doesValueMatchFilter(objVal, filter));
+      case "$not":
+        return !doesValueMatchFilter(objVal, value.$not);
+      case "$sum":
+        if (Array.isArray(objVal))
+          return doesValueMatchFilter(
+            objVal.reduce((acc, val) => acc + val, 0),
+            value.$sum
+          );
+        return doesValueMatchFilter(objVal, value.$sum);
+      case "$length":
+        if (Array.isArray(objVal)) return doesValueMatchFilter(objVal.length, value.$length);
+        return doesValueMatchFilter(1, value.$length);
+      case "$eq":
+        if (Array.isArray(objVal)) return objVal.some((o) => value.$eq === o);
+        return value.$eq === objVal;
+      case "$neq":
+        if (Array.isArray(objVal)) return objVal.some((o) => value.$neq !== o);
+        return value.$neq !== objVal;
+      case "$some":
+        if (Array.isArray(objVal)) return objVal.some((o) => doesValueMatchFilter(o, value.$some));
+        return doesValueMatchFilter(objVal, value.$some);
+      case "$nsome":
+        if (Array.isArray(objVal)) return objVal.some((o) => doesValueMatchFilter(o, value.$nsome));
+        return doesValueMatchFilter(objVal, value.$nsome);
+      case "$every":
+        if (Array.isArray(objVal)) return objVal.every((o) => doesValueMatchFilter(o, value.$every));
+        return doesValueMatchFilter(objVal, value.$every);
+      case "$nevery":
+        if (Array.isArray(objVal)) return objVal.every((o) => doesValueMatchFilter(o, value.$nevery));
+        return doesValueMatchFilter(objVal, value.$nevery);
+      case "$in":
+        value.$in = recalculateObjectWithDocument(value.$in, documents);
+        if (!Array.isArray(value.$in)) value.$in = [value.$in];
+        if (Array.isArray(objVal)) {
+          return objVal.some((o) => {
+            const result = value.$in.some((v) => {
+              const ret = doesValueMatchFilter(o, v);
+              return ret;
+            });
+            return result;
+          });
+        }
+        return value.$in.some((v) => doesValueMatchFilter(objVal, v));
+      // return value.$in.includes(objVal);
+      // MICHAL: Pokud bude spravne fungovat $in tak podle toho predelat $nin
+      case "$nin":
+        if (!Array.isArray(value.$nin)) value.$nin = [value.$nin];
+        if (Array.isArray(objVal)) return objVal.some((o) => !value.$nin.includes(o));
+        return !value.$nin.includes(objVal);
+      // Every in array
+      case "$ein":
+        if (!Array.isArray(value.$ein)) value.$ein = [value.$ein];
+        if (Array.isArray(objVal)) return objVal.every((o) => value.$ein.includes(o));
+        return value.$ein.includes(objVal);
+      // Not every in array
+      case "$nein":
+        if (!Array.isArray(value.$nein)) value.$nein = [value.$nein];
+        if (Array.isArray(objVal)) return objVal.every((o) => !value.$nein.includes(o));
+        return !value.$nein.includes(objVal);
+      // case "$include":
+      // case "$incl":
+      //     return objVal?.includes(value.$include);
+      case "$gt":
+        return objVal > value.$gt;
+      case "$gte":
+        return objVal >= recalculateObjectWithDocument(value.$gte, documents);
+      case "$lt":
+        return objVal < value.$lt;
+      case "$lte":
+        return objVal <= value.$lte;
+      case "$regex":
+        const regex = new RegExp(escapeRegExp(value.$regex));
+        if (regex) return regex.test(objVal);
+        else return false;
+      case "$iregex":
+        const iregex = new RegExp(escapeRegExp(value.$iregex), "i");
+        if (iregex) return iregex.test(objVal);
+        else return false;
+      // Pomocne - lze resit regexem
+      case "$sw":
+        return value.$sw.startsWith(objVal);
+      case "$ew":
+        return value.$sw.endsWith(objVal);
+      case "$nsw":
+        return !value.$sw.startsWith(objVal);
+      case "$new":
+        return !value.$sw.endsWith(objVal);
+      default:
+        return doesObjectMatchFilter(objVal, value, documents);
+    }
+  } else {
+    if (Array.isArray(objVal)) return objVal.some((o) => value === o);
+    return objVal === value;
+  }
+}
+function doesObjectMatchFilter(obj, filter, documents = {}) {
+  if (!filter) return true;
+  if (Object.keys(filter)?.includes("$rule")) {
+    const result2 = doesObjectMatchFilter(obj, filter.$rule, documents);
+    if (result2 === true) {
+      return result2;
+    } else {
+      return filter.$message || false;
+    }
+  }
+  let error;
+  const result = Object.entries(filter).every(([key, value]) => {
+    let objVal;
+    if (key.startsWith("$")) {
+      switch (key) {
+        case "$date":
+          objVal = dayjs().format("YYYY-MM-DD");
+          break;
+        case "$time":
+          objVal = dayjs().format("HH:mm:ss");
+          break;
+        case "$datetime":
+          objVal = dayjs().format("YYYY-MM-DD HH:mm:ss");
+          break;
+        case "$day":
+          objVal = dayjs().day();
+          break;
+        case "$or":
+          return value.some((condition) => {
+            const res = doesObjectMatchFilter(obj, condition, documents);
+            if (typeof res === "boolean") return res;
+            error = res;
+            return false;
+          });
+        case "$and":
+          return value.every((condition) => {
+            const res = doesObjectMatchFilter(obj, condition, documents);
+            if (typeof res === "boolean") return res;
+            error = res;
+            return false;
+          });
+        case "$first":
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              if (Object.keys(v)?.includes("$rule")) {
+                if (doesObjectMatchFilter(documents, v.$rule, documents)) {
+                  return doesValueMatchFilter(obj, v.$value);
+                }
+              } else {
+                return doesValueMatchFilter(obj, v);
+              }
+            }
+            return false;
+          } else return doesObjectMatchFilter(obj, value, documents);
+        case "$last":
+          if (Array.isArray(value)) {
+            for (const v of value.reverse()) {
+              if (Object.keys(v)?.includes("$rule")) {
+                if (doesObjectMatchFilter(documents, v.$rule, documents)) {
+                  return doesValueMatchFilter(obj, v.$value);
+                }
+              } else {
+                return doesValueMatchFilter(obj, v);
+              }
+            }
+            return false;
+          } else return doesObjectMatchFilter(obj, value, documents);
+        case "$gt":
+        case "$gte":
+        case "$lt":
+        case "$lte":
+        case "$eq":
+        case "$neq":
+          const resp = recalculateObjectWithDocument(filter, obj);
+          return resp;
+        default:
+          objVal = getValueByDotPath(obj, key.substring(1));
+      }
+    } else {
+      objVal = getValueByDotPath(obj, key);
+    }
+    if (key.endsWith("?") && objVal === void 0) return true;
+    if (objVal === void 0) return false;
+    const rrr = doesValueMatchFilter(objVal, value, documents);
+    return rrr;
+  });
+  return error || result;
+}
+var filterDocuments = (documents, filter) => {
+  if (!filter) return documents;
+  if (!documents) return void 0;
+  if (!Array.isArray(documents)) {
+    if (doesObjectMatchFilter(documents, filter)) return documents;
+    else return null;
+  } else return documents.filter((item) => doesObjectMatchFilter(item, filter));
+};
+var filterDocumentsAsync = async (documents, filter) => {
+  return new Promise((resolve) => {
+    const response = filterDocuments(documents, filter);
+    resolve(response);
+  });
+};
+var dataStoreFilterObject = (obj, filter) => {
+  if (!filter) return obj;
+  if (!obj) return void 0;
+  const result = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      if (doesObjectMatchFilter(obj[key], filter)) {
+        result[key] = obj[key];
+      }
+    }
+  }
+  return result;
+};
+function uuid() {
+  return Crypto.randomUUID();
+}
+function isUuid(val) {
+  if (typeof val !== "string") return false;
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidPattern.test(val);
+}
+
+// src/handleData.ts
+var saveData = async ({
+  providerId,
+  newData,
+  dateUpdate,
+  SQLite: SQLite3
+}) => {
+  console.time(`[SQL] saveData ${providerId}`);
+  const batchSize = 8e3;
+  const placeholders = "(?,?,?,?)";
+  var i = 0;
+  for (i = 0; i < newData.length / batchSize; i++) {
+    const values = [];
+    for (let j = 0; j < batchSize; j++) {
+      if (i * batchSize + j < newData.length) {
+        const { id, ...item } = newData[i * batchSize + j];
+        values.push(id, JSON.stringify(item), providerId, dateUpdate);
+      }
+    }
+    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);
+    systemLog("axios", "saveData result: ", JSON.stringify(row));
+  }
+  console.timeEnd(`[SQL] saveData ${providerId}`);
+};
+var buildUri = ({
+  method,
+  dataSource,
+  variant
+}) => {
+  if (dataSource.crud) {
+    if (method === "update" && dataSource.crud.updates) {
+      if (variant && dataSource.crud.updates[variant]) return dataSource.crud.updates[variant];
+      if (dataSource.crud[method]) return dataSource.crud[method];
+      const firstUpdateUri = Object.values(dataSource.crud.updates)[0];
+      if (firstUpdateUri) return firstUpdateUri;
+    }
+    const crudUri = dataSource.crud[method];
+    if (crudUri) return crudUri;
+  }
+  return dataSource.uri || `${dataSource.model || ""}/`;
+};
+var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, changeTime }) => {
+  if (dataSource) systemLog("axios", "GET Data Source: ", buildUri({ dataSource, method: "read" }));
+  else systemLog("axios", "No DataSource for ", id);
+  let persistedData = [];
+  var params = { ...dataSource?.params };
+  if (dataSource?.filter) params.filter = dataSource.filter;
+  if (dataSource?.select) params.select = dataSource.select;
+  try {
+    var newData;
+    if (dataSource?.data) {
+      newData = dataSource.data;
+    } else if (dataSource?.file) {
+      const response = await fetch(`${process.env.PUBLIC_URL}/${dataSource.file}`);
+      newData = await response.json();
+    } else {
+      if (changeTime) {
+        params.changeTime = changeTime;
+      } else if (isPersisting && SQLite3) {
+        console.time("Persisted Data");
+        const qDatum = await SQLite3.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) }));
+        console.timeEnd("Persisted Data");
+      }
+      if (dataSource) {
+        systemLog("axios", "Params: ", JSON.stringify(params));
+        const axiosResponse = await axios.get(buildUri({ dataSource, method: "read" }), { params });
+        if (schema && !dataSource.readAllFields) {
+          if (Array.isArray(axiosResponse.data.data)) {
+            newData = [];
+            axiosResponse.data.data.forEach((element) => {
+              if (element._deleted) {
+                newData.push(element);
+                return;
+              }
+              var newRow = {};
+              Object.keys(schema).forEach((key) => {
+                if (typeof element === "object") {
+                  newRow[key] = schema[key].source ? element[schema[key].source] : element[key];
+                } else {
+                  newRow[key] = element;
+                }
+              });
+              if (!newRow.id && ["payments", "deliveries"].includes(id)) {
+                if (element.id) {
+                  newRow.id = id + "-" + element.id;
+                } else {
+                  newRow.id = uuid();
+                }
+              }
+              newData.push(newRow);
+            });
+          } else {
+            newData = {};
+            Object.keys(schema).forEach((key) => {
+              newData[key] = schema[key].source ? axiosResponse.data.data[schema[key].source] : axiosResponse.data.data[key];
+            });
+          }
+        } else {
+          newData = axiosResponse.data.data;
+        }
+        systemLog(
+          "axios",
+          `(SERVER TIME: ${axiosResponse.data.queryTime}) Data:`,
+          newData.length || "single",
+          "items, Size:",
+          JSON.stringify(newData).length,
+          "Bytes"
+        );
+        if (isPersisting && SQLite3) {
+          await saveData({ providerId: id, newData, SQLite: SQLite3, dateUpdate: axiosResponse.data.queryAt || (/* @__PURE__ */ new Date()).toISOString() });
+        }
+      }
+    }
+    if (Array.isArray(newData)) {
+      console.time("Maping");
+      const map = /* @__PURE__ */ new Map();
+      persistedData.forEach((item) => map.set(item.id, item));
+      newData.forEach((item) => map.set(item.id, item));
+      let updatedArray = [];
+      updatedArray.push(...map.values());
+      systemLog(
+        "axios",
+        `getData - Polozky ${id} persisted: ${persistedData.length}, newData: ${newData.length},  vysledek: ${updatedArray.length}`
+      );
+      console.timeEnd("Maping");
+      return updatedArray;
+    } else {
+      return newData || [];
+    }
+  } catch (e) {
+    console.error(`[AXIOS] CHYBA PRI NACITANI DAT Z: ${JSON.stringify(dataSource, null, 2)}
+${e}`);
+    return [];
+  }
+};
+var postData = async ({ dataSource, variant, schema, val }) => {
+  try {
+    systemLog("axios", "POST", buildUri({ dataSource, variant, method: "create" }), ", Data: ", JSON.stringify(val, null, 2));
+    const response = await axios.post(`${buildUri({ dataSource, variant, method: "create" })}`, val);
+    systemLog("axios", "POST Query Time: ", response.data.queryTime);
+    systemLog("axios", "POST Response Data: ", response.data.data.length, " B");
+    return response.data.data;
+  } catch (e) {
+    console.error(`POST DATA: ${e}`);
+    return e;
+  }
+};
+var patchData = async ({ dataSource, variant, data }) => {
+  try {
+    systemLog("axios", "PATCH: ", buildUri({ dataSource, variant, method: "update" }), ", Data: ", JSON.stringify(data, null, 2));
+    const response = await axios.patch(buildUri({ dataSource, variant, method: "update" }), data);
+    response.data?.queryTime && systemLog("axios", "PATCH Server Query Time: ", response.data.queryTime);
+    systemLog("axios", "PATCH Response Data: ", response.data.data.length, " Bytes");
+    return response.data.data;
+  } catch (e) {
+    console.error(`[AXIOS] PATCH DATA: ${e}`);
+  }
+};
+var deleteData = async ({ dataSource, data }) => {
+  try {
+    systemLog("axios", "deleteData DS:", dataSource);
+    const response = await axios.delete(`${buildUri({ dataSource, method: "delete" })}`, data);
+    response.data?.queryTime && systemLog("axios", "deleteData - Query Time: ", response.data.queryTime);
+    systemLog("axios", "deleteData Data response: ", response.data.data);
+    return response.data.data;
+  } catch (e) {
+    console.error(`DELETE DATA: ${e}`);
+    return e;
+  }
+};
+
+// 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) => {
+  return templateString.replace(/<%=(.*?)%>/g, (match, variable) => {
+    const key = variable.trim();
+    return data[key] !== void 0 ? String(data[key]) : match;
+  });
+};
+function renderJSONTemplate(val, data) {
+  if (val == null) return val;
+  if (!data) return val;
+  const valString = JSON.stringify(val, (_key, value) => {
+    if (value instanceof RegExp) {
+      return { __regex__: value.source };
+    }
+    return value;
+  });
+  const renderedOutput = _renderMyTemplate(valString, data);
+  const parsedObj = JSON.parse(renderedOutput, (_key, value) => {
+    if (typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, "__regex__")) {
+      const regexValue = value.__regex__;
+      return new RegExp(regexValue);
+    }
+    return value;
+  });
+  return parsedObj;
+}
+
+// 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({});
+var DataStoreActionsContext = createContext({});
+var DataStoreStableContext = createContext({});
+var useDataStoreActions = () => useContext(DataStoreActionsContext);
+var useFilteredDocuments = (filter) => {
+  const [activeFilter, setFilter] = useState(filter);
+  const [data, setData] = useState();
+  const documents = useContext(DataStoreDocumentsContext);
+  useEffect(() => {
+    setFilter(filter);
+  }, [JSON.stringify(filter)]);
+  useEffect(() => {
+    console.time("Filter");
+    if (activeFilter && documents && Object.keys(documents).length > 0 && Object.keys(activeFilter).length > 0) {
+      const result = dataStoreFilterObject(documents, activeFilter);
+      const dataArray = Object.keys(result).map((id) => ({
+        id,
+        ...result[id]
+      }));
+      if (!isEqual(data, dataArray)) setData(dataArray);
+    }
+    console.timeEnd("Filter");
+  }, [activeFilter, documents]);
+  return { documents: data || documents, setFilter };
+};
+var useDocuments = () => {
+  const documents = useContext(DataStoreDocumentsContext);
+  return { documents };
+};
+var useProviderDocuments = (provider, settings) => {
+  const documents = useContext(DataStoreDocumentsContext);
+  const providers = useContext(DataStoreProvidersContext);
+  const docs = useMemo(() => {
+    console.log("useProviderDocuments", provider);
+    const d = {};
+    providers[provider]?.data.forEach((id) => {
+      if (settings?.filter && !doesObjectMatchFilter(documents[id], settings.filter)) return;
+      let result = documents[id];
+      if (providers[provider].depend) {
+        result = recalculateObjectWithDocument(documents[id], documents[providers[provider].depend]);
+      } else if (settings?.documentId) {
+        result = recalculateObjectWithDocument(documents[id], documents[settings.documentId]);
+      } else if (settings?.document) {
+        result = recalculateObjectWithDocument(documents[id], settings.document);
+      }
+      d[id] = result;
+    });
+    return d;
+  }, [providers[provider]?.lastUpdate, documents[providers[provider]?.depend], settings?.filter, settings?.documentId, settings?.document]);
+  return { documents: docs };
+};
+var useProvider = (val) => {
+  const providers = useContext(DataStoreProvidersContext);
+  return providers[val];
+};
+var useDataStore = () => {
+  const meta = useContext(DataStoreContext);
+  const documents = useContext(DataStoreDocumentsContext);
+  const providers = useContext(DataStoreProvidersContext);
+  const actions = useContext(DataStoreActionsContext);
+  return { ...meta, documents, providers, ...actions };
+};
+var modelTemplateIdMap = {
+  brands: "brandId",
+  payments: "paymentId",
+  profiles: "profileId",
+  user: "userId"
+};
+var buildDocumentTemplateParams = (model, documentId) => {
+  const templateIdKey = modelTemplateIdMap[model] || `${model.replace(/s$/, "")}Id`;
+  return {
+    id: documentId,
+    documentId,
+    productId: 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");
+      }
+    }
+    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}`;
+    }
+    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,
+      model,
+      data,
+      lastUpdate = (/* @__PURE__ */ new Date()).toISOString()
+    }) => {
+      if (!usePersistentStorage) return;
+      await SQLite2.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
+        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;
+            });
+            await updateDocuments({ model: key, documents: updateData, mode: "replace" });
+            stats.updated++;
+          }
+        } catch (e) {
+          stats.failed++;
+          console.error("[DSP] synchronizeDataStore provider error:", key, e);
+        }
+      }
+    } 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();
+      }
+    } 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);
+      }
+      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);
+        }
+        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);
+                  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);
+                  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 && 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;
+        }
+      }
+      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 {
+                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 };
+            }
+            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);
+          }
+        }
+      }
+    },
+    [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: ",
+        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;
+      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 && 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;
+          } else {
+            setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
+            newC[documentId] = providerListenersCount;
+          }
+          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;
+            } 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);
+            }
+          });
+          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;
+      });
+    },
+    [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;
+        }
+      });
+    },
+    [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
+        });
+        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;
+          }
+        });
+        setCounterDocuments((prev) => {
+          {
+            const newC = { ...prev };
+            dataList.forEach((i) => {
+              if (newC[i]) {
+                newC[i] = newC[i] + 1;
+              } else {
+                newC[i] = 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
+        }));
+        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);
+            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
+    ]
+  );
+  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
+import { useCallback as useCallback2, useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useState as useState2, useSyncExternalStore } from "react";
+var useDataProvider = (id, params, dataFilter, settings) => {
+  const [providerId, setProviderId] = useState2(null);
+  const [filter, setFilter] = useState2(null);
+  const {
+    dispatch,
+    presetProviders,
+    updateProviderListeners,
+    subscribeToProvider,
+    getProviderLastUpdate,
+    getExternalDocuments,
+    getExternalProviders
+  } = useContext2(DataStoreStableContext);
+  const providerVersion = useSyncExternalStore(
+    useCallback2(
+      (onStoreChange) => {
+        if (!providerId) return () => {
+        };
+        return subscribeToProvider(providerId, onStoreChange);
+      },
+      [providerId, subscribeToProvider]
+    ),
+    useCallback2(() => {
+      if (!providerId) return null;
+      return getProviderLastUpdate(providerId);
+    }, [providerId, getProviderLastUpdate]),
+    () => null
+  );
+  systemLog("usedp", `${id} - ${providerId}`);
+  useEffect2(() => {
+    if (id === void 0 || typeof id === "boolean" && id === false) return;
+    var retId;
+    const currentProviders = getExternalProviders();
+    if (dataFilter) setFilter(dataFilter);
+    if (typeof id === "object") {
+      const prov = renderJSONTemplate(id, params ?? void 0);
+      setProviderId(prov.id);
+      retId = prov.id;
+      dispatch("registerProvider", prov);
+    } else {
+      if (presetProviders[id]) {
+        const prov = renderJSONTemplate(presetProviders[id], params ?? void 0);
+        setProviderId(prov.id);
+        retId = prov.id;
+        if (currentProviders[prov.id]) {
+          systemLog("usedp", "Provider:", prov.id, "existuje");
+          if (!currentProviders[prov.id]?.isPermanent) updateProviderListeners(prov.id, 1);
+        } else {
+          systemLog("usedp", "Registruji novy provider:", prov.id);
+          dispatch("registerProvider", prov);
+        }
+      } else {
+        systemLog("usedp", "Neznamy provider ", id, params, dataFilter, settings);
+      }
+    }
+    return () => {
+      const activeProviders = getExternalProviders();
+      const presetProvider = presetProviders[retId];
+      if (!presetProvider?.isPermanent && !activeProviders[retId]?.isPermanent) {
+        systemLog("usedp", "Unregister Provider: ", retId, "-", activeProviders[retId]);
+        dispatch("unregisterProvider", retId);
+      }
+    };
+  }, []);
+  const update = (val) => {
+    systemLog("usedp", "UPDATUJI: ", providerId, ", data: ", val);
+    dispatch("updateDataStore", { id: providerId, data: val });
+  };
+  const updateItem = ({ params: params2, data, variant, documentId = void 0 }, callback) => {
+    systemLog("usedp", "UPDATUJI:", providerId, ", variant:", variant, ", documentId: ", documentId, ", params:", params2, ", data:", data);
+    dispatch("updateDataStore", { id: providerId, variant, params: params2, data, documentId }, callback);
+  };
+  const deleteItem = ({ params: params2, data }, callback) => {
+    systemLog("usedp", "DELETE FROM:", providerId, ", params:", params2, "data:", data);
+    dispatch("deleteProviderItem", { providerId, data, params: params2 }, callback);
+  };
+  const createItem = (data, callback) => {
+    dispatch("createProviderItem", { id, data }, callback);
+  };
+  const provider = useMemo2(() => {
+    systemLog("usedp", "Vytvoreni dat: ", filter);
+    const providers = getExternalProviders();
+    const documents = getExternalDocuments();
+    if (!providerId || !providers[providerId]) {
+      return {
+        data: [],
+        schema: void 0
+      };
+    }
+    let docs = [];
+    providers[providerId]?.data.forEach((docId) => {
+      let dData = documents[docId];
+      if (providers[providerId].depend) {
+        dData = recalculateObjectWithDocument(documents[docId], documents[providers[providerId].depend]);
+      } else if (settings?.documentId) {
+        dData = recalculateObjectWithDocument(documents[docId], documents[settings.documentId]);
+      } else if (settings?.document) {
+        dData = recalculateObjectWithDocument(documents[docId], settings.document);
+      }
+      docs.push({
+        id: docId,
+        ...dData
+      });
+    });
+    systemLog("usedp", "KonecVytvoreni dat: ", providerId);
+    if (filter) {
+      systemLog("usedp", "Jdu filterovat: ", JSON.stringify(filter));
+      docs = filterDocuments(docs, filter);
+      systemLog("usedp", "Konec filteru: ");
+    }
+    return {
+      ...providers[providerId],
+      data: docs
+    };
+  }, [providerId, providerVersion, settings?.document, settings?.documentId, getExternalProviders, getExternalDocuments]);
+  systemLog("usedp", `${providerId} END`);
+  return {
+    // provider,
+    documents: provider.data,
+    schema: provider.schema,
+    // dispatch,
+    update,
+    updateItem,
+    deleteItem,
+    createItem
+  };
+};
+
+// src/useDocument.ts
+import { useContext as useContext3, useMemo as useMemo3 } from "react";
+var useDocument = ({ documentId, model, provider, fields, allFields }) => {
+  const documents = useContext3(DataStoreDocumentsContext);
+  const { dispatch } = useContext3(DataStoreActionsContext);
+  systemLog("useDocument", "USE DOCUMENT", documentId);
+  const documentResult = useMemo3(() => {
+    systemLog("useDocument", "Hledam v Documents", fields);
+    let missingFields = [];
+    let result = {};
+    if (documents[documentId]) {
+      if (Array.isArray(fields) && fields.length > 0) {
+        for (const field of fields) {
+          if (!Object.prototype.hasOwnProperty.call(documents[documentId], field)) {
+            missingFields.push(field);
+          } else {
+            result[field] = documents[documentId][field];
+          }
+        }
+      } else {
+        result = documents[documentId];
+      }
+      if (missingFields.length > 0) {
+        systemLog("useDocument", "Musim jeste stahnout", missingFields);
+        dispatch("updateDocument", {
+          documentId,
+          model,
+          fields: missingFields
+        });
+      }
+    } else {
+      result = {};
+    }
+    systemLog("useDocument", JSON.stringify(result));
+    return { document: result };
+  }, [documentId, JSON.stringify(fields), documents[documentId]]);
+  return documentResult;
+};
+
+// src/useProviderActions.tsx
+import { useContext as useContext4, useEffect as useEffect4 } from "react";
+var useProviderActions = (providerId, data) => {
+  const providers = useContext4(DataStoreProvidersContext);
+  const { dispatch, presetProviders, updateProviderListeners } = useContext4(DataStoreActionsContext);
+  const providerKey = providerId;
+  systemLog("usedp", `${providerId}`);
+  useEffect4(() => {
+    if (providers[providerId]) {
+      systemLog("usedp", "Provider:", providerId, "existuje");
+      if (!providers[providerId].isPermanent) updateProviderListeners(providerId, 1);
+    } else {
+      if (presetProviders[providerKey]) {
+        const templateData = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+        const prov = renderJSONTemplate(presetProviders[providerKey], templateData);
+        systemLog("usedp", "Registruji novy provider:", providerId);
+        dispatch("registerProvider", prov);
+      } else {
+        systemLog("usedp", "Neznamy provider ", providerId);
+      }
+      return () => {
+        if (!presetProviders[providerKey]?.isPermanent && !providers[providerId]?.isPermanent) {
+          dispatch("unregisterProvider", providerId);
+        }
+      };
+    }
+  }, []);
+  const update = (val) => {
+    systemLog("usedp", "UPDATUJI: ", providerId, ", data: ", val);
+    dispatch("updateDataStore", { id: providerId, data: val });
+  };
+  const updateItem = ({ params, data: data2, variant, documentId = void 0 }, callback) => {
+    dispatch("updateDataStore", { id: providerId, variant, params, data: data2, documentId }, callback);
+  };
+  const deleteItem = ({ params, data: data2 }, callback) => {
+    dispatch("deleteProviderItem", { providerId, data: data2, params }, callback);
+  };
+  const createItem = (data2, callback) => {
+    systemLog("usedp", "createItem Prov. id:", providerId);
+    dispatch("createProviderItem", { id: providerId, data: data2 }, callback);
+  };
+  return {
+    schema: providers[providerId]?.schema,
+    update,
+    updateItem,
+    deleteItem,
+    createItem
+  };
+};
+
+// src/logColors.ts
+var COLOR_WHITE = `\x1B[37m%s\x1B[0m`;
+var COLOR_MAGENTA = `\x1B[35m%s\x1B[0m`;
+var COLOR_BLUE = `\x1B[34m%s\x1B[0m`;
+var COLOR_CYAN = `\x1B[36m%s\x1B[0m`;
+var COLOR_GREEN = `\x1B[32m%s\x1B[0m`;
+var COLOR_RED = `\x1B[31m%s\x1B[0m`;
+var COLOR_ERROR = `\x1B[31m%s\x1B[0m`;
+var COLOR_YELLOW = `\x1B[33m%s\x1B[0m`;
+var COLOR_ORANGE = `\x1B[38;5;208m%s\x1B[0m`;
+var COLOR_WARNING = `\x1B[33m%s\x1B[0m`;
+var COLOR_PROVIDER = COLOR_MAGENTA;
+var COLOR_CONTEXT = COLOR_MAGENTA;
+var COLOR_RENDER = COLOR_BLUE;
+var COLOR_FUNCTION = COLOR_CYAN;
+var COLOR_SCREEN = COLOR_GREEN;
+var COLOR_SOCKET = COLOR_CYAN;
+var COLOR_SOCKETS = COLOR_YELLOW;
+var COLOR_AXIOS = COLOR_YELLOW;
+var COLOR_APP = COLOR_BLUE;
+var COLOR_DS = COLOR_MAGENTA;
+export {
+  COLOR_APP,
+  COLOR_AXIOS,
+  COLOR_BLUE,
+  COLOR_CONTEXT,
+  COLOR_CYAN,
+  COLOR_DS,
+  COLOR_ERROR,
+  COLOR_FUNCTION,
+  COLOR_GREEN,
+  COLOR_MAGENTA,
+  COLOR_ORANGE,
+  COLOR_PROVIDER,
+  COLOR_RED,
+  COLOR_RENDER,
+  COLOR_SCREEN,
+  COLOR_SOCKET,
+  COLOR_SOCKETS,
+  COLOR_WARNING,
+  COLOR_WHITE,
+  COLOR_YELLOW,
+  DataStoreActionsContext,
+  DataStoreContext,
+  DataStoreDocumentsContext,
+  DataStoreProvider_default as DataStoreProvider,
+  DataStoreProvidersContext,
+  DataStoreStableContext,
+  SQLite2 as SQLite,
+  dataStoreFilterObject,
+  doesObjectMatchFilter,
+  doesValueMatchFilter,
+  filterDocuments,
+  filterDocumentsAsync,
+  getValueByRules,
+  isUuid,
+  recalculateObjectWithDocument,
+  useDataProvider,
+  useDataStore,
+  useDataStoreActions,
+  useDocument,
+  useDocuments,
+  useFilteredDocuments,
+  useProvider,
+  useProviderActions,
+  useProviderDocuments,
+  uuid
+};
+//# sourceMappingURL=index.js.map