@mgarlik/datastore 0.1.26 → 0.2.0

package/dist/index.js

@@ -665,7 +665,14 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime
         }).filter((item) => item !== null);
       }
       if (dataSource) {
-        const axiosResponse = await axios.get(buildUri({ dataSource, method: "read" }), { params: serializeParams(params) });
+        const serializedParams = serializeParams(params);
+        console.log("[HANDLE DATA] outgoing read params", buildUri({ dataSource, method: "read" }), serializedParams);
+        console.assert(
+          !(typeof serializedParams.filter === "string" && serializedParams.filter.includes('"$source"')),
+          "[HANDLE DATA] unresolved $source reached outgoing filter",
+          serializedParams.filter
+        );
+        const axiosResponse = await axios.get(buildUri({ dataSource, method: "read" }), { params: serializedParams });
         if (schema && !dataSource.readAllFields) {
           const mapBySchema = (element) => {
             const mappedRow = {};
@@ -750,9 +757,8 @@ var deleteData = async ({ dataSource, data }) => {
   }
 };
 
-// src/DataStoreProvider.tsx
-import { io as ioSockets } from "socket.io-client";
-import axios2 from "axios";
+// src/sourceResolution.ts
+import { filterJsonDocuments as filterDocuments2 } from "@mgarlik/json-filter";
 
 // src/templates.ts
 var _renderMyTemplate = (templateString, data) => {
@@ -781,7 +787,84 @@ function renderJSONTemplate(val, data) {
   return parsedObj;
 }
 
+// src/sourceResolution.ts
+var resolveProviderRef = (providerId, providers, presetProviders, params) => {
+  if (providers[providerId]) {
+    return { templateId: providerId, runtimeId: providerId };
+  }
+  if (presetProviders[providerId]) {
+    const renderedProvider = renderJSONTemplate(presetProviders[providerId], params ?? void 0);
+    return { templateId: providerId, runtimeId: renderedProvider.id };
+  }
+  return null;
+};
+var collectObjectSourceProviders = (obj, result) => {
+  if (!obj || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    obj.forEach((item) => collectObjectSourceProviders(item, result));
+    return;
+  }
+  if (obj.$source?.dataProvider) {
+    result.add(String(obj.$source.dataProvider));
+  }
+  if (obj.dataSource?.dataProvider) {
+    result.add(String(obj.dataSource.dataProvider));
+  }
+  Object.values(obj).forEach((value) => collectObjectSourceProviders(value, result));
+};
+var collectSourceProviders = (value) => {
+  const result = /* @__PURE__ */ new Set();
+  collectObjectSourceProviders(value, result);
+  return Array.from(result);
+};
+var resolveDynamicValue = (value, context, stack = []) => {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveDynamicValue(item, context, stack));
+  }
+  if (typeof value !== "object") return value;
+  const sourceKeys = Object.keys(value);
+  if (sourceKeys.length === 1 && sourceKeys[0] === "$source") {
+    return resolveSourceConfig(value.$source, context, stack);
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = resolveDynamicValue(item, context, stack);
+  }
+  return result;
+};
+var resolveSourceConfig = (source, context, stack = []) => {
+  if (!source?.dataProvider) return source?.val ? null : void 0;
+  const resolvedRef = resolveProviderRef(source.dataProvider, context.providers, context.presetProviders, context.params);
+  if (!resolvedRef) return source.val ? null : void 0;
+  if (stack.includes(resolvedRef.runtimeId)) {
+    throw new Error(`Cyclic $source reference detected for provider ${resolvedRef.runtimeId}`);
+  }
+  const provider = context.providers[resolvedRef.runtimeId];
+  if (!provider) return source.map ? [] : source.val ? null : void 0;
+  const providerDocuments = Array.isArray(provider.data) ? provider.data.map((docId) => {
+    const doc = context.documents[docId];
+    if (!doc) return null;
+    return { id: docId, ...doc };
+  }).filter((item) => item !== null) : [];
+  const resolvedFilter = source.filter ? resolveDynamicValue(source.filter, context, [...stack, resolvedRef.runtimeId]) : void 0;
+  const filteredDocuments = resolvedFilter ? filterDocuments2(providerDocuments, resolvedFilter) : providerDocuments;
+  if (source.map) {
+    return filteredDocuments.map((item) => getValueByDotPath(item, source.map)).filter((item) => item !== void 0);
+  }
+  if (source.val) {
+    if (filteredDocuments.length === 0) return null;
+    if (filteredDocuments.length > 1) {
+      throw new Error(`$source.val expects exactly one document from ${source.dataProvider}, got ${filteredDocuments.length}`);
+    }
+    return getValueByDotPath(filteredDocuments[0], source.val) ?? null;
+  }
+  return filteredDocuments;
+};
+
 // src/DataStoreProvider.tsx
+import { io as ioSockets } from "socket.io-client";
+import axios2 from "axios";
 import isEqual from "lodash/isEqual.js";
 import { jsx } from "react/jsx-runtime";
 var DataStoreContext = createContext({});
@@ -816,11 +899,13 @@ var useDocuments = () => {
 var useProviderDocuments = (provider, settings) => {
   const documents = useContext(DataStoreDocumentsContext);
   const providers = useContext(DataStoreProvidersContext);
+  const presetProviders = useContext(DataStoreStableContext).presetProviders;
+  const resolvedFilter = settings?.filter ? resolveDynamicValue(settings.filter, { providers, documents, presetProviders }) : void 0;
   const docs = useMemo(() => {
     console.log("useProviderDocuments", provider);
     const d = {};
     providers[provider]?.data.forEach((id) => {
-      if (settings?.filter && !doesObjectMatchFilter(documents[id], settings.filter)) return;
+      if (resolvedFilter && !doesObjectMatchFilter(documents[id], resolvedFilter)) return;
       let result = documents[id];
       if (providers[provider].depend) {
         result = recalculateObjectWithDocument(documents[id], documents[providers[provider].depend]);
@@ -832,7 +917,16 @@ var useProviderDocuments = (provider, settings) => {
       d[id] = result;
     });
     return d;
-  }, [providers[provider]?.lastUpdate, documents[providers[provider]?.depend], settings?.filter, settings?.documentId, settings?.document]);
+  }, [
+    providers[provider]?.lastUpdate,
+    documents[providers[provider]?.depend],
+    settings?.filter,
+    settings?.documentId,
+    settings?.document,
+    providers,
+    documents,
+    presetProviders
+  ]);
   return { documents: docs };
 };
 var useProvider = (val) => {
@@ -892,6 +986,8 @@ var DataStoreProvider = forwardRef(
     const [counterProviders, setCounterProviders] = useState({});
     const [counterDocuments, setCounterDocuments] = useState({});
     const didInitialLiveSyncRef = useRef(false);
+    const providerDynamicSourceStateRef = useRef({});
+    const providerDynamicRefreshInProgressRef = useRef(/* @__PURE__ */ new Set());
     const persistenceStorage = useMemo(
       () => usePersistentStorage ? storage : null,
       [storage, usePersistentStorage]
@@ -1007,6 +1103,7 @@ var DataStoreProvider = forwardRef(
             const response = await getData({
               id: key,
               ...rest,
+              dataSource: resolveDynamicValue(rest.dataSource || {}, { providers, documents, presetProviders }),
               changeTime: lastUpdate.time
             });
             if (response.length > 0) {
@@ -1291,7 +1388,10 @@ var DataStoreProvider = forwardRef(
           if (dP) {
             const dataFromSource = await getData({
               id: dP.id,
-              dataSource: { ...dP.dataSource, params: { select: fields.join(" ") } },
+              dataSource: resolveDynamicValue(
+                { ...dP.dataSource, params: { select: fields.join(" ") } },
+                { providers, documents, presetProviders }
+              ),
               isPersisting: !!dP.isPersisting && !!persistenceStorage,
               schema: dP.schema,
               SQLite: persistenceStorage || void 0
@@ -1314,9 +1414,10 @@ var DataStoreProvider = forwardRef(
                 data: Array.isArray(provider?.data) ? [...provider.data] : []
               };
               var socketListeners = providerNext.dataSource?.socketListeners || [];
+              const resolvedProviderFilter = providerNext.dataSource?.filter ? resolveDynamicValue(providerNext.dataSource.filter, { providers, documents, presetProviders }) : void 0;
               if (socketListeners.length === 0) {
                 if (providerNext.data.includes(documentId)) {
-                  if (!providerNext.dataSource?.filter || filterDocuments(documentForFilter, providerNext.dataSource?.filter)) {
+                  if (!resolvedProviderFilter || filterDocuments(documentForFilter, resolvedProviderFilter)) {
                     listeningProviders++;
                     providerNext.lastUpdate = {
                       id: uuid(),
@@ -1335,7 +1436,7 @@ var DataStoreProvider = forwardRef(
                 }
               } else if (socketListeners.includes(model) || // socketListeners.includes(documentId) ||
               key === model) {
-                if (!providerNext.dataSource.filter || filterDocuments(documentForFilter, providerNext.dataSource.filter)) {
+                if (!resolvedProviderFilter || filterDocuments(documentForFilter, resolvedProviderFilter)) {
                   listeningProviders++;
                   providerNext.lastUpdate = {
                     id: uuid(),
@@ -1454,7 +1555,8 @@ var DataStoreProvider = forwardRef(
         Object.keys(providers).forEach((key) => {
           const provider = providers[key];
           var socketListeners = provider.dataSource?.socketListeners;
-          if ((socketListeners?.includes(model) || key === model) && (!provider.dataSource?.filter || filterDocuments(newDocument, provider.dataSource?.filter))) {
+          const resolvedProviderFilter = provider.dataSource?.filter ? resolveDynamicValue(provider.dataSource.filter, { providers, documents, presetProviders }) : void 0;
+          if ((socketListeners?.includes(model) || key === model) && (!resolvedProviderFilter || filterDocuments(newDocument, resolvedProviderFilter))) {
             if (!provider.data.includes(documentId)) {
               setCounterDocuments((prev) => {
                 const newC = { ...prev };
@@ -1617,6 +1719,171 @@ var DataStoreProvider = forwardRef(
       },
       [setSockets, socket]
     );
+    const buildResolvedDataSourceSnapshot = useCallback(
+      (providerId) => {
+        const provider = providers[providerId];
+        if (!provider?.dataSource) return null;
+        const dependencies = collectSourceProviders(provider.dataSource);
+        if (dependencies.length === 0) return null;
+        const resolvedDataSource = resolveDynamicValue(provider.dataSource, { providers, documents, presetProviders });
+        return {
+          resolvedDataSource,
+          signature: JSON.stringify(resolvedDataSource ?? {}),
+          socketFilter: resolvedDataSource?.filter ?? {}
+        };
+      },
+      [providers, documents, presetProviders]
+    );
+    const refreshProviderFromResolvedDataSource = useCallback(
+      async (providerId, resolvedDataSource, resolvedSocketFilter) => {
+        const provider = providers[providerId];
+        if (!provider) return;
+        console.log("[DSP][dynamic] reload start", {
+          providerId,
+          previousCount: Array.isArray(provider.data) ? provider.data.length : 0
+        });
+        const dataFromSource = await getData({
+          schema: provider.schema,
+          dataSource: resolvedDataSource,
+          id: providerId,
+          isPersisting: !!provider.isPersisting && !!persistenceStorage,
+          SQLite: persistenceStorage || void 0
+        });
+        const nextDocumentIds = [];
+        const nextDocuments = {};
+        const sourceItems = Array.isArray(dataFromSource) ? dataFromSource : [dataFromSource];
+        sourceItems.forEach((item) => {
+          if (!item || typeof item !== "object") return;
+          const { id, ...data } = item;
+          const normalizedId = id || uuid();
+          nextDocumentIds.push(normalizedId);
+          nextDocuments[normalizedId] = documents[normalizedId] ? { ...documents[normalizedId], ...data } : data;
+        });
+        const previousDocumentIds = Array.isArray(provider.data) ? provider.data : [];
+        const previousSet = new Set(previousDocumentIds);
+        const nextSet = new Set(nextDocumentIds);
+        const addedDocumentIds = nextDocumentIds.filter((itemId) => !previousSet.has(itemId));
+        const removedDocumentIds = previousDocumentIds.filter((itemId) => !nextSet.has(itemId));
+        setCounterDocuments((prev) => {
+          const nextCounters = { ...prev };
+          const documentsToDelete = [];
+          removedDocumentIds.forEach((itemId) => {
+            if (!nextCounters[itemId] || nextCounters[itemId] <= 1) {
+              delete nextCounters[itemId];
+              documentsToDelete.push(itemId);
+            } else {
+              nextCounters[itemId] = nextCounters[itemId] - 1;
+            }
+          });
+          addedDocumentIds.forEach((itemId) => {
+            nextCounters[itemId] = (nextCounters[itemId] || 0) + 1;
+          });
+          setDocuments((prevDocs) => {
+            const nextDocs = { ...prevDocs };
+            documentsToDelete.forEach((itemId) => {
+              delete nextDocs[itemId];
+            });
+            Object.entries(nextDocuments).forEach(([itemId, itemData]) => {
+              nextDocs[itemId] = itemData;
+            });
+            return nextDocs;
+          });
+          return nextCounters;
+        });
+        setProviders((prev) => {
+          if (!prev[providerId]) return prev;
+          return {
+            ...prev,
+            [providerId]: {
+              ...prev[providerId],
+              data: nextDocumentIds,
+              _resolvedSocketFilter: resolvedSocketFilter,
+              lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
+            }
+          };
+        });
+        console.log("[DSP][dynamic] reload done", {
+          providerId,
+          nextCount: nextDocumentIds.length,
+          added: addedDocumentIds.length,
+          removed: removedDocumentIds.length,
+          socketFilter: resolvedSocketFilter
+        });
+        if (provider?.isPersisting && persistenceStorage) {
+          await Promise.all(removedDocumentIds.map((itemId) => removePersistedDocument(itemId)));
+          await Promise.all(
+            Object.entries(nextDocuments).map(
+              ([itemId, itemData]) => persistDocument({ documentId: itemId, model: providerId, data: itemData })
+            )
+          );
+        }
+      },
+      [providers, documents, persistenceStorage, removePersistedDocument, persistDocument]
+    );
+    useEffect(() => {
+      const trackedProviderIds = Object.keys(providers).filter((providerId) => {
+        const provider = providers[providerId];
+        return !!provider?.dataSource && collectSourceProviders(provider.dataSource).length > 0;
+      });
+      const trackedSet = new Set(trackedProviderIds);
+      Object.keys(providerDynamicSourceStateRef.current).forEach((providerId) => {
+        if (!trackedSet.has(providerId)) {
+          delete providerDynamicSourceStateRef.current[providerId];
+        }
+      });
+      trackedProviderIds.forEach((providerId) => {
+        const snapshot = buildResolvedDataSourceSnapshot(providerId);
+        if (!snapshot) return;
+        const previousSnapshot = providerDynamicSourceStateRef.current[providerId];
+        if (!previousSnapshot) {
+          providerDynamicSourceStateRef.current[providerId] = {
+            signature: snapshot.signature,
+            socketFilter: snapshot.socketFilter
+          };
+          return;
+        }
+        if (previousSnapshot.signature === snapshot.signature) return;
+        if (providerDynamicRefreshInProgressRef.current.has(providerId)) return;
+        console.log("[DSP][dynamic] dataSource changed", {
+          providerId,
+          previousFilter: previousSnapshot.socketFilter,
+          nextFilter: snapshot.socketFilter
+        });
+        providerDynamicSourceStateRef.current[providerId] = {
+          signature: snapshot.signature,
+          socketFilter: snapshot.socketFilter
+        };
+        providerDynamicRefreshInProgressRef.current.add(providerId);
+        const provider = providers[providerId];
+        const socketListeners = provider?.dataSource?.socketListeners;
+        (async () => {
+          try {
+            if (socketListeners && !isEqual(previousSnapshot.socketFilter, snapshot.socketFilter)) {
+              console.log("[DSP][dynamic] socket filter refresh", {
+                providerId,
+                socketListeners,
+                previousFilter: previousSnapshot.socketFilter,
+                nextFilter: snapshot.socketFilter
+              });
+              unregisterProviderSockets(socketListeners, previousSnapshot.socketFilter);
+              registerProviderSockets(socketListeners, snapshot.socketFilter);
+            }
+            await refreshProviderFromResolvedDataSource(providerId, snapshot.resolvedDataSource, snapshot.socketFilter);
+          } catch (error) {
+            console.error("[DataStoreProvider] dynamic dataSource refresh error", { providerId, error });
+          } finally {
+            providerDynamicRefreshInProgressRef.current.delete(providerId);
+          }
+        })();
+      });
+    }, [
+      providers,
+      documents,
+      buildResolvedDataSourceSnapshot,
+      refreshProviderFromResolvedDataSource,
+      registerProviderSockets,
+      unregisterProviderSockets
+    ]);
     const updateProviderListeners = useCallback(
       async (id, val) => {
         setCounterProviders((prev) => {
@@ -1629,7 +1896,7 @@ var DataStoreProvider = forwardRef(
               const newS = { ...prevS };
               const removeSocketListeners = [];
               const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
-              const providerFilter = prevP[id].dataSource?.filter;
+              const providerFilter = prevP[id]._resolvedSocketFilter ?? prevP[id].dataSource?.filter;
               const normalizedFilter = providerFilter ?? {};
               providerSocketListeners.forEach((socketName) => {
                 if (!newS[socketName]) return;
@@ -1693,9 +1960,10 @@ var DataStoreProvider = forwardRef(
           result = providers[id];
         } else {
           try {
+            const resolvedDataSource = resolveDynamicValue(newItem.dataSource || {}, { providers, documents, presetProviders });
             const dataFromSource = await getData({
               schema: newItem.schema,
-              dataSource: newItem.dataSource || {},
+              dataSource: resolvedDataSource,
               id: newItem.id,
               isPersisting: !!newItem.isPersisting && !!persistenceStorage,
               SQLite: persistenceStorage || void 0
@@ -1734,6 +2002,7 @@ var DataStoreProvider = forwardRef(
             result = {
               ...provider,
               data: dataList,
+              _resolvedSocketFilter: resolvedDataSource?.filter ?? {},
               lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
             };
             setProviders((prev) => ({
@@ -1746,7 +2015,7 @@ var DataStoreProvider = forwardRef(
             }));
             if (provider.dataSource?.socketListeners) {
               console.log("TATATATA");
-              registerProviderSockets(provider.dataSource.socketListeners, provider.dataSource.filter);
+              registerProviderSockets(provider.dataSource.socketListeners, resolvedDataSource?.filter ?? {});
             }
           } catch (error) {
             console.error("[DataStoreProvider] registerProvider:error", { id: newItem.id, error });
@@ -1767,7 +2036,10 @@ var DataStoreProvider = forwardRef(
                 [itemId]: prev[itemId] - 1
               };
             } else {
-              unregisterProviderSockets(providers[itemId]?.dataSource.socketListeners, providers[itemId]?.dataSource.filter);
+              unregisterProviderSockets(
+                providers[itemId]?.dataSource.socketListeners,
+                providers[itemId]?._resolvedSocketFilter ?? providers[itemId]?.dataSource.filter
+              );
               setCounterDocuments((cd) => {
                 const newC = { ...cd };
                 const deleteDocumentIds = [];
@@ -1869,14 +2141,15 @@ 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";
-import { filterJsonDocuments as filterDocuments2 } from "@mgarlik/json-filter";
+import { filterJsonDocuments as filterDocuments3 } from "@mgarlik/json-filter";
 var findAllDataProviders = (obj) => {
   if (!obj || typeof obj !== "object") return [];
   if (obj.dataSource?.dataProvider) return [obj.dataSource.dataProvider];
+  if (obj.$source?.dataProvider) return [obj.$source.dataProvider];
   if (Array.isArray(obj)) return obj.flatMap(findAllDataProviders);
   return Object.values(obj).flatMap(findAllDataProviders);
 };
-var resolveProviderRef = (providerId, providers, presetProviders, params) => {
+var resolveProviderRef2 = (providerId, providers, presetProviders, params) => {
   if (providers[providerId]) {
     return { templateId: providerId, runtimeId: providerId };
   }
@@ -1907,7 +2180,7 @@ var createOptionFromDocument = (doc, map) => {
 var resolveDataSourcesDeep = (obj, providers, documents, presetProviders, params, logLabel = "options") => {
   if (!obj || typeof obj !== "object") return obj;
   if (obj.dataSource?.dataProvider) {
-    const providerRef = resolveProviderRef(obj.dataSource.dataProvider, providers, presetProviders, params);
+    const providerRef = resolveProviderRef2(obj.dataSource.dataProvider, providers, presetProviders, params);
     const optionProvider = providers[providerRef.runtimeId];
     if (!optionProvider) {
       systemLog("usedp", `Nenalezen provider pro ${logLabel}`, obj.dataSource.dataProvider);
@@ -1919,7 +2192,8 @@ var resolveDataSourcesDeep = (obj, providers, documents, presetProviders, params
       return { id: docId, ...docData };
     }).filter((item) => !!item);
     if (obj.dataSource.filter) {
-      optionDocuments = filterDocuments2(optionDocuments, obj.dataSource.filter);
+      const resolvedFilter = resolveDynamicValue(obj.dataSource.filter, { providers, documents, presetProviders, params });
+      optionDocuments = filterDocuments3(optionDocuments, resolvedFilter);
     }
     return optionDocuments.map((item) => createOptionFromDocument(item, obj.dataSource.map));
   }
@@ -1962,15 +2236,21 @@ var useDataProvider = (id, params, dataFilter, settings) => {
     if (!providerId || !providers[providerId]) return [];
     const schema = providers[providerId]?.schema;
     const layout = providers[providerId]?.layout;
-    const allProviderIds = [...findAllDataProviders(schema), ...findAllDataProviders(layout)];
+    const dataSourceFilter = providers[providerId]?.dataSource?.filter;
+    const allProviderIds = [
+      ...findAllDataProviders(schema),
+      ...findAllDataProviders(layout),
+      ...collectSourceProviders(dataSourceFilter),
+      ...collectSourceProviders(dataFilter)
+    ];
     const uniqueProviders = {};
     allProviderIds.forEach((dataProvider) => {
-      const resolved = resolveProviderRef(dataProvider, providers, presetProviders, params);
+      const resolved = resolveProviderRef2(dataProvider, providers, presetProviders, params);
       if (resolved.runtimeId === providerId) return;
       uniqueProviders[resolved.runtimeId] = resolved;
     });
     return Object.values(uniqueProviders);
-  }, [providerId, providerVersion, getExternalProviders, presetProviders, params]);
+  }, [providerId, providerVersion, getExternalProviders, presetProviders, params, dataFilter]);
   const dependentProviderVersion = useSyncExternalStore(
     useCallback2(
       (onStoreChange) => {
@@ -2027,7 +2307,7 @@ var useDataProvider = (id, params, dataFilter, settings) => {
         dispatch("unregisterProvider", retId);
       }
     };
-  }, []);
+  }, [id, params, dataFilter, dependentProviderVersion, dispatch, getExternalProviders, presetProviders, updateProviderListeners]);
   useEffect2(() => {
     if (dependentProviders.length === 0) return;
     const currentProviders = getExternalProviders();
@@ -2110,7 +2390,8 @@ var useDataProvider = (id, params, dataFilter, settings) => {
     systemLog("usedp", "KonecVytvoreni dat: ", providerId);
     if (filter) {
       systemLog("usedp", "Jdu filterovat: ", JSON.stringify(filter));
-      docs = filterDocuments2(docs, filter);
+      const resolvedFilter = resolveDynamicValue(filter, { providers, documents, presetProviders, params });
+      docs = filterDocuments3(docs, resolvedFilter);
       systemLog("usedp", "Konec filteru: ");
     }
     const schema = providers[providerId].schema;
@@ -2186,41 +2467,134 @@ var useDocument = ({ documentId, model, provider, fields, allFields }) => {
 };
 
 // src/useProviderActions.tsx
-import { useContext as useContext4, useEffect as useEffect4 } from "react";
+import { useCallback as useCallback3, useContext as useContext4, useEffect as useEffect4, useMemo as useMemo4, useSyncExternalStore as useSyncExternalStore2 } from "react";
+var resolveProviderRef3 = (templateId, providers, presetProviders, data) => {
+  if (providers[templateId]) {
+    return { templateId, runtimeId: templateId };
+  }
+  if (presetProviders[templateId]) {
+    const templateData = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+    const rendered = renderJSONTemplate(presetProviders[templateId], templateData);
+    return { templateId, runtimeId: rendered.id };
+  }
+  return { templateId, runtimeId: templateId };
+};
 var useProviderActions = (providerId, data) => {
   const providers = useContext4(DataStoreProvidersContext);
   const { dispatch, presetProviders, updateProviderListeners } = useContext4(DataStoreActionsContext);
+  const { subscribeToProvider, getProviderLastUpdate, getExternalProviders } = useContext4(DataStoreStableContext);
   const providerKey = providerId;
+  const templateData = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+  const runtimeProviderRef = useMemo4(() => {
+    const currentProviders = getExternalProviders();
+    return resolveProviderRef3(providerKey, currentProviders, presetProviders, data);
+  }, [providerKey, getExternalProviders, presetProviders, data]);
+  const dependentProviders = useMemo4(() => {
+    const currentProviders = getExternalProviders();
+    const sourceFilter = currentProviders[runtimeProviderRef.runtimeId]?.dataSource?.filter ?? (runtimeProviderRef.runtimeId === providerKey ? presetProviders[providerKey]?.dataSource?.filter : void 0);
+    const sourceProviderIds = collectSourceProviders(sourceFilter);
+    const uniqueProviders = {};
+    sourceProviderIds.forEach((itemId) => {
+      const resolved = resolveProviderRef3(itemId, currentProviders, presetProviders, data);
+      if (resolved.runtimeId === runtimeProviderRef.runtimeId) return;
+      uniqueProviders[resolved.runtimeId] = resolved;
+    });
+    return Object.values(uniqueProviders);
+  }, [runtimeProviderRef.runtimeId, providerKey, getExternalProviders, presetProviders, data]);
+  const dependentProviderVersion = useSyncExternalStore2(
+    useCallback3(
+      (onStoreChange) => {
+        if (dependentProviders.length === 0) return () => {
+        };
+        const unsubscribers = dependentProviders.map((providerRef) => subscribeToProvider(providerRef.runtimeId, onStoreChange));
+        return () => {
+          unsubscribers.forEach((unsubscribe) => unsubscribe?.());
+        };
+      },
+      [dependentProviders, subscribeToProvider]
+    ),
+    useCallback3(() => {
+      if (dependentProviders.length === 0) return "";
+      return dependentProviders.map((providerRef) => String(getProviderLastUpdate(providerRef.runtimeId) ?? "")).join("|");
+    }, [dependentProviders, getProviderLastUpdate]),
+    () => ""
+  );
   systemLog("usedp", `${providerId}`);
   useEffect4(() => {
-    if (providers[providerId]) {
-      systemLog("usedp", "Provider:", providerId, "existuje");
-      if (!providers[providerId].isPermanent) updateProviderListeners(providerId, 1);
+    const runtimeId = runtimeProviderRef.runtimeId;
+    const currentProviders = getExternalProviders();
+    if (currentProviders[runtimeId]) {
+      systemLog("usedp", "Provider:", runtimeId, "existuje");
+      if (!currentProviders[runtimeId].isPermanent) updateProviderListeners(runtimeId, 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);
+        systemLog("usedp", "Registruji novy provider:", runtimeId);
         dispatch("registerProvider", prov);
       } else {
-        systemLog("usedp", "Neznamy provider ", providerId);
+        systemLog("usedp", "Neznamy provider ", runtimeId);
       }
-      return () => {
-        if (!presetProviders[providerKey]?.isPermanent && !providers[providerId]?.isPermanent) {
-          dispatch("unregisterProvider", providerId);
-        }
-      };
     }
-  }, []);
+    return () => {
+      const activeProviders = getExternalProviders();
+      if (!presetProviders[providerKey]?.isPermanent && !activeProviders[runtimeId]?.isPermanent) {
+        dispatch("unregisterProvider", runtimeId);
+      }
+    };
+  }, [
+    providerKey,
+    runtimeProviderRef.runtimeId,
+    dependentProviderVersion,
+    dispatch,
+    getExternalProviders,
+    presetProviders,
+    templateData,
+    updateProviderListeners
+  ]);
+  useEffect4(() => {
+    if (dependentProviders.length === 0) return;
+    const currentProviders = getExternalProviders();
+    const incrementedProviders = [];
+    const createdProviders = [];
+    dependentProviders.forEach((providerRef) => {
+      if (currentProviders[providerRef.runtimeId]) {
+        if (!currentProviders[providerRef.runtimeId]?.isPermanent) {
+          updateProviderListeners(providerRef.runtimeId, 1);
+          incrementedProviders.push(providerRef.runtimeId);
+        }
+        return;
+      }
+      if (!presetProviders[providerRef.templateId]) return;
+      const renderedProvider = renderJSONTemplate(presetProviders[providerRef.templateId], templateData);
+      dispatch("registerProvider", renderedProvider);
+      createdProviders.push({
+        templateId: providerRef.templateId,
+        runtimeId: renderedProvider.id
+      });
+    });
+    return () => {
+      incrementedProviders.forEach((id) => {
+        updateProviderListeners(id, -1);
+      });
+      if (createdProviders.length === 0) return;
+      const activeProviders = getExternalProviders();
+      createdProviders.forEach((providerRef) => {
+        const presetProvider = presetProviders[providerRef.templateId];
+        if (!presetProvider?.isPermanent && !activeProviders[providerRef.runtimeId]?.isPermanent) {
+          dispatch("unregisterProvider", providerRef.runtimeId);
+        }
+      });
+    };
+  }, [dependentProviders, dispatch, getExternalProviders, presetProviders, templateData, updateProviderListeners]);
   const update = (val) => {
     systemLog("usedp", "UPDATUJI: ", providerId, ", data: ", val);
-    dispatch("updateDataStore", { id: providerId, data: val });
+    dispatch("updateDataStore", { id: runtimeProviderRef.runtimeId, data: val });
   };
   const updateItem = ({ params, data: data2, variant, documentId = void 0 }, callback) => {
-    dispatch("updateDataStore", { id: providerId, variant, params, data: data2, documentId }, callback);
+    dispatch("updateDataStore", { id: runtimeProviderRef.runtimeId, variant, params, data: data2, documentId }, callback);
   };
   const deleteItem = ({ params, data: data2 }, callback) => {
-    dispatch("deleteProviderItem", { providerId, data: data2, params }, callback);
+    dispatch("deleteProviderItem", { providerId: runtimeProviderRef.runtimeId, data: data2, params }, callback);
   };
   const createItem = ({
     data: data2,
@@ -2228,16 +2602,16 @@ var useProviderActions = (providerId, data) => {
     callback
   }) => {
     systemLog("usedp", "createItem Prov. id:", providerId);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       const wrappedCallback = (result) => {
         callback?.(result);
         resolve(result);
       };
-      dispatch("createProviderItem", { id: providerId, data: data2, variant }, wrappedCallback);
+      dispatch("createProviderItem", { id: runtimeProviderRef.runtimeId, data: data2, variant }, wrappedCallback);
     });
   };
   return {
-    schema: providers[providerId]?.schema,
+    schema: providers[runtimeProviderRef.runtimeId]?.schema,
     update,
     updateItem,
     deleteItem,