@mgarlik/datastore 0.1.11 → 0.1.12

package/dist/index.cjs

@@ -2067,6 +2067,79 @@ var DataStoreProvider_default = DataStoreProvider;
 
 // src/useDataProvider.tsx
 var import_react2 = require("react");
+var getDynamicOptionsConfig = (schema) => {
+  if (!schema) return [];
+  const configs = [];
+  Object.entries(schema).forEach(([fieldKey, schemaItem]) => {
+    if (!schemaItem || typeof schemaItem !== "object") return;
+    if (schemaItem.options && !Array.isArray(schemaItem.options) && typeof schemaItem.options === "object" && schemaItem.options.dataProvider) {
+      configs.push({
+        fieldKey,
+        dataProvider: schemaItem.options.dataProvider,
+        optionKeys: schemaItem.options.optionKeys,
+        filter: schemaItem.options.filter
+      });
+      return;
+    }
+    if (schemaItem.dataSource?.dataProvider) {
+      configs.push({
+        fieldKey,
+        dataProvider: schemaItem.dataSource.dataProvider,
+        optionKeys: schemaItem.optionKeys,
+        filter: schemaItem.filter
+      });
+    }
+  });
+  return configs;
+};
+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 {
+    templateId: providerId,
+    runtimeId: providerId
+  };
+};
+var createOptionFromDocument = (doc, optionKeys) => {
+  const valuePath = optionKeys?.value || "id";
+  const optionValue = getValueByDotPath(doc, valuePath, doc.id);
+  const labelDefinition = optionKeys?.label;
+  let optionLabel = "";
+  let optionIcon;
+  if (typeof labelDefinition === "string") {
+    optionLabel = String(getValueByDotPath(doc, labelDefinition, optionValue ?? ""));
+  } else if (labelDefinition && typeof labelDefinition === "object") {
+    const labelPath = labelDefinition.title || "name";
+    optionLabel = String(getValueByDotPath(doc, labelPath, optionValue ?? ""));
+    if (labelDefinition.icon) {
+      optionIcon = getValueByDotPath(doc, labelDefinition.icon);
+    }
+  } else {
+    optionLabel = String(optionValue ?? "");
+  }
+  if (optionIcon) {
+    return {
+      value: optionValue,
+      label: optionLabel,
+      icon: optionIcon
+    };
+  }
+  return {
+    value: optionValue,
+    label: optionLabel
+  };
+};
 var useDataProvider = (id, params, dataFilter, settings) => {
   const [providerId, setProviderId] = (0, import_react2.useState)(null);
   const [filter, setFilter] = (0, import_react2.useState)(null);
@@ -2094,6 +2167,37 @@ var useDataProvider = (id, params, dataFilter, settings) => {
     }, [providerId, getProviderLastUpdate]),
     () => null
   );
+  const dependentProviders = (0, import_react2.useMemo)(() => {
+    const providers = getExternalProviders();
+    if (!providerId || !providers[providerId]?.schema) return [];
+    const schema = providers[providerId]?.schema;
+    const optionConfigs = getDynamicOptionsConfig(schema);
+    const uniqueProviders = {};
+    optionConfigs.forEach((cfg) => {
+      const resolved = resolveProviderRef(cfg.dataProvider, providers, presetProviders, params);
+      if (resolved.runtimeId === providerId) return;
+      uniqueProviders[resolved.runtimeId] = resolved;
+    });
+    return Object.values(uniqueProviders);
+  }, [providerId, providerVersion, getExternalProviders, presetProviders, params]);
+  const dependentProviderVersion = (0, import_react2.useSyncExternalStore)(
+    (0, import_react2.useCallback)(
+      (onStoreChange) => {
+        if (dependentProviders.length === 0) return () => {
+        };
+        const unsubscribers = dependentProviders.map((providerRef) => subscribeToProvider(providerRef.runtimeId, onStoreChange));
+        return () => {
+          unsubscribers.forEach((unsubscribe) => unsubscribe?.());
+        };
+      },
+      [dependentProviders, subscribeToProvider]
+    ),
+    (0, import_react2.useCallback)(() => {
+      if (dependentProviders.length === 0) return "";
+      return dependentProviders.map((providerRef) => String(getProviderLastUpdate(providerRef.runtimeId) ?? "")).join("|");
+    }, [dependentProviders, getProviderLastUpdate]),
+    () => ""
+  );
   systemLog("usedp", `${id} - ${providerId}`);
   (0, import_react2.useEffect)(() => {
     if (id === void 0 || typeof id === "boolean" && id === false) return;
@@ -2133,6 +2237,45 @@ var useDataProvider = (id, params, dataFilter, settings) => {
       }
     };
   }, []);
+  (0, import_react2.useEffect)(() => {
+    if (dependentProviders.length === 0) return;
+    const currentProviders = getExternalProviders();
+    const incrementedProviders = [];
+    const createdProviders = [];
+    dependentProviders.forEach((providerRef) => {
+      if (providerRef.runtimeId === providerId) return;
+      if (currentProviders[providerRef.runtimeId]) {
+        if (!currentProviders[providerRef.runtimeId]?.isPermanent) {
+          updateProviderListeners(providerRef.runtimeId, 1);
+          incrementedProviders.push(providerRef.runtimeId);
+        }
+        return;
+      }
+      if (!presetProviders[providerRef.templateId]) {
+        systemLog("usedp", "Neznamy provider v schema.options", providerRef.templateId);
+        return;
+      }
+      const renderedProvider = renderJSONTemplate(presetProviders[providerRef.templateId], params ?? void 0);
+      dispatch("registerProvider", renderedProvider);
+      createdProviders.push({
+        templateId: providerRef.templateId,
+        runtimeId: renderedProvider.id
+      });
+    });
+    return () => {
+      incrementedProviders.forEach((id2) => {
+        updateProviderListeners(id2, -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, providerId, getExternalProviders, updateProviderListeners, dispatch, presetProviders, params]);
   const update = (val) => {
     systemLog("usedp", "UPDATUJI: ", providerId, ", data: ", val);
     dispatch("updateDataStore", { id: providerId, data: val });
@@ -2185,16 +2328,61 @@ var useDataProvider = (id, params, dataFilter, settings) => {
       docs = filterDocuments(docs, filter);
       systemLog("usedp", "Konec filteru: ");
     }
+    const schema = providers[providerId].schema;
+    let resolvedSchema = schema;
+    if (schema) {
+      const optionConfigs = getDynamicOptionsConfig(schema);
+      if (optionConfigs.length > 0) {
+        resolvedSchema = { ...schema };
+        optionConfigs.forEach((cfg) => {
+          const providerRef = resolveProviderRef(cfg.dataProvider, providers, presetProviders, params);
+          const optionProvider = providers[providerRef.runtimeId];
+          if (!optionProvider) {
+            systemLog("usedp", "Nenalezen provider pro schema.options", cfg.dataProvider);
+            return;
+          }
+          let optionDocuments = (optionProvider.data || []).map((docId) => {
+            const docData = documents[docId];
+            if (!docData) return null;
+            return {
+              id: docId,
+              ...docData
+            };
+          }).filter((item) => !!item);
+          if (cfg.filter) {
+            optionDocuments = filterDocuments(optionDocuments, cfg.filter);
+          }
+          const computedOptions = optionDocuments.map((item) => createOptionFromDocument(item, cfg.optionKeys));
+          const nextItem = {
+            ...resolvedSchema[cfg.fieldKey],
+            options: computedOptions
+          };
+          resolvedSchema[cfg.fieldKey] = nextItem;
+        });
+      }
+    }
     return {
       ...providers[providerId],
-      data: docs
+      data: docs,
+      schema: resolvedSchema
     };
-  }, [providerId, providerVersion, settings?.document, settings?.documentId, getExternalProviders, getExternalDocuments]);
+  }, [
+    providerId,
+    providerVersion,
+    dependentProviderVersion,
+    settings?.document,
+    settings?.documentId,
+    getExternalProviders,
+    getExternalDocuments,
+    presetProviders,
+    params
+  ]);
   systemLog("usedp", `${providerId} END`);
   return {
     // provider,
     documents: provider.data,
     schema: provider.schema,
+    layout: provider.layout,
     // dispatch,
     update,
     updateItem,