@dnb/eufemia/extensions/forms/Form/DataContext/useData.js

DNB Eufemia Design System UI Library

"use client";

import { useCallback, useContext, useMemo, useRef, useSyncExternalStore } from 'react';
import pointer from "../../utils/json-pointer/index.js";
import { createReferenceKey, createSharedState, useSharedState } from "../../../../shared/helpers/useSharedState.js";
import useMountEffect from "../../../../shared/helpers/useMountEffect.js";
import DataContext from "../../DataContext/Context.js";
import { structuredClone } from "../../../../shared/helpers/structuredClone.js";
export default function useData(id = undefined, initialData = undefined) {
  const sharedDataRef = useRef(null);
  const sharedAttachmentsRef = useRef(null);
  sharedDataRef.current = useSharedState(id, initialData);
  sharedAttachmentsRef.current = id ? createSharedState(createReferenceKey(id, 'attachments')) : null;
  const dataContext = useContext(DataContext);
  const subscribeContextData = useCallback(callback => {
    if (!id && dataContext?.subscribeDataValue) {
      return dataContext.subscribeDataValue('/', callback);
    }
    return () => undefined;
  }, [dataContext, id]);
  const getContextDataSnapshot = useCallback(() => {
    if (!id && dataContext?.getDataValue) {
      return dataContext.getDataValue('/');
    }
    return undefined;
  }, [dataContext, id]);
  const contextData = useSyncExternalStore(subscribeContextData, getContextDataSnapshot, getContextDataSnapshot);
  return useDataReturn({
    id,
    initialData,
    sharedDataRef,
    sharedAttachmentsRef,
    dataContext,
    contextData,
    errorMessage: 'useData needs to run inside DataContext (Form.Handler) or have a valid id'
  });
}
export function useDataReturn({
  id,
  initialData,
  sharedDataRef,
  sharedAttachmentsRef,
  dataContext,
  dataContextRef,
  contextData,
  errorMessage
}) {
  const fallbackDataContextRef = useRef(dataContext);
  fallbackDataContextRef.current = dataContext;
  const getDataContext = useCallback(() => {
    var _dataContextRef$curre;
    return (_dataContextRef$curre = dataContextRef?.current) !== null && _dataContextRef$curre !== void 0 ? _dataContextRef$curre : fallbackDataContextRef.current;
  }, [dataContextRef]);
  const contextDataDependency = id ? undefined : dataContext;
  if (!id && !getDataContext().hasContext) {
    throw new Error(errorMessage);
  }
  const getCurrentData = useCallback(() => {
    var _dataContext$getDataV;
    if (id) {
      return sharedDataRef.current?.get?.();
    }
    const dataContext = getDataContext();
    return (_dataContext$getDataV = dataContext?.getDataValue?.('/')) !== null && _dataContext$getDataV !== void 0 ? _dataContext$getDataV : dataContext?.data;
  }, [getDataContext, id, sharedDataRef]);
  const getExistingData = useCallback(() => {
    var _ref, _ref2, _ref3;
    const liveStoreData = id ? sharedDataRef.current?.get?.() : null;
    const liveContextData = !id ? getCurrentData() : null;
    const dataContext = getDataContext();
    return structuredClone((_ref = (_ref2 = (_ref3 = liveStoreData !== null && liveStoreData !== void 0 ? liveStoreData : liveContextData) !== null && _ref3 !== void 0 ? _ref3 : dataContext?.data) !== null && _ref2 !== void 0 ? _ref2 : sharedAttachmentsRef.current?.data?.internalDataRef?.current) !== null && _ref !== void 0 ? _ref : {});
  }, [getDataContext, getCurrentData, id, sharedAttachmentsRef, sharedDataRef]);
  const set = useCallback(newData => {
    if (id) {
      sharedDataRef.current?.set(newData);
    } else {
      getDataContext().setData?.(newData);
    }
  }, [getDataContext, id, sharedDataRef]);
  const update = useCallback((path, value = undefined) => {
    const existingData = getExistingData();
    const existingValue = pointer.has(existingData, path) ? pointer.get(existingData, path) : undefined;
    const newValue = typeof value === 'function' ? value(existingValue) : value;
    if (newValue !== existingValue) {
      pointer.set(existingData, path, newValue);
      if (id) {
        sharedDataRef.current?.extend(existingData);
      } else {
        getDataContext().updateDataValue?.(path, newValue);
      }
    }
  }, [getDataContext, getExistingData, id, sharedDataRef]);
  const remove = useCallback(path => {
    const existingData = getExistingData();
    if (pointer.has(existingData, path)) {
      pointer.remove(existingData, path);
      if (id) {
        sharedDataRef.current?.set(existingData);
      } else {
        getDataContext().setData?.(existingData);
      }
    }
  }, [getDataContext, getExistingData, id, sharedDataRef]);
  const reduceToVisibleFields = useCallback((data, options = {}) => {
    if (id) {
      return sharedAttachmentsRef.current.data?.visibleDataHandler?.(data, options);
    }
    return getDataContext()?.visibleDataHandler?.(data, options);
  }, [contextDataDependency, getDataContext, id, sharedAttachmentsRef]);
  const filterData = useCallback((filter, data = getCurrentData()) => {
    if (id) {
      return sharedAttachmentsRef.current.data?.filterDataHandler?.(data, filter);
    }
    return getDataContext()?.filterDataHandler?.(data, filter);
  }, [contextDataDependency, getCurrentData, getDataContext, id, sharedAttachmentsRef]);
  const getValue = useCallback(path => {
    const dataContext = getDataContext();
    if (!id && dataContext?.getDataValue) {
      return dataContext.getDataValue(path);
    }
    const data = getCurrentData();
    if (pointer.has(data, path)) {
      return pointer.get(data, path);
    }
    return undefined;
  }, [getCurrentData, getDataContext, id]);
  useMountEffect(() => {
    if (id && !sharedDataRef.current?.hadInitialData && initialData) {
      sharedDataRef.current?.extend(initialData, {
        forceSync: true
      });
    }
  });
  const data = id ? sharedDataRef.current?.data : contextData !== null && contextData !== void 0 ? contextData : getCurrentData();
  return useMemo(() => ({
    data,
    remove,
    update,
    set,
    getValue,
    reduceToVisibleFields,
    filterData
  }), [data, remove, update, set, getValue, reduceToVisibleFields, filterData]);
}
//# sourceMappingURL=useData.js.map