@dnb/eufemia/cjs/extensions/forms/Form/Isolation/Isolation.js

DNB Eufemia Design System UI Library

"use strict";
"use client";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
require("core-js/modules/es.string.replace.js");
require("core-js/modules/web.dom-collections.iterator.js");
var _react = _interopRequireWildcard(require("react"));
var _useMountEffect = _interopRequireDefault(require("../../../../shared/helpers/useMountEffect"));
var _jsonPointer = _interopRequireDefault(require("../../utils/json-pointer"));
var _componentHelper = require("../../../../shared/component-helper");
var _isAsync = require("../../../../shared/helpers/isAsync");
var _useDataValue = _interopRequireDefault(require("../../hooks/useDataValue"));
var _DataContext = require("../../DataContext");
var _SectionContext = _interopRequireDefault(require("../Section/SectionContext"));
var _useReportError = _interopRequireDefault(require("./useReportError"));
var _IsolationCommitButton = _interopRequireDefault(require("./IsolationCommitButton"));
var _IsolationResetButton = _interopRequireDefault(require("./IsolationResetButton"));
var _Provider = require("../../DataContext/Provider");
var _IsolationDataReference = require("./IsolationDataReference");
var _IsolatedContainer2 = _interopRequireWildcard(require("./IsolatedContainer"));
var _IsolationContext = _interopRequireDefault(require("./IsolationContext"));
var _structuredClone = _interopRequireDefault(require("@ungap/structured-clone"));
var _BubbleValidation;
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function IsolationProvider(props) {
  var _IsolatedContainer;
  const [dataReferenceFallback] = (0, _react.useState)(() => {
    if (!(props !== null && props !== void 0 && props.dataReference)) {
      return (0, _IsolationDataReference.createDataReference)();
    }
  });
  const {
    children,
    onPathChange,
    onCommit: onCommitProp,
    onClear: onClearProp,
    transformOnCommit: transformOnCommitProp,
    commitHandleRef,
    bubbleValidation,
    preventUncommittedChanges,
    data,
    defaultData,
    dataReference = dataReferenceFallback,
    resetDataAfterCommit
  } = props;
  const [, forceUpdate] = (0, _react.useReducer)(() => ({}), {});
  const internalDataRef = (0, _react.useRef)();
  const localDataRef = (0, _react.useRef)({});
  const dataContextRef = (0, _react.useRef)(null);
  const outerContext = (0, _react.useContext)(_DataContext.Context);
  const {
    path: pathSection
  } = (0, _react.useContext)(_SectionContext.default) || {};
  const {
    handlePathChange: handlePathChangeOuter,
    data: dataOuter
  } = outerContext || {};
  const {
    moveValueToPath
  } = (0, _useDataValue.default)();
  const onPathChangeHandler = (0, _react.useCallback)(async (path, value) => {
    if (localDataRef.current === _Provider.clearedData) {
      localDataRef.current = {};
    }
    _jsonPointer.default.set(localDataRef.current, path, value);
    if (pathSection) {
      path = path.replace(pathSection, '');
    }
    return await (onPathChange === null || onPathChange === void 0 ? void 0 : onPathChange(path, value));
  }, [onPathChange, pathSection]);
  const onUpdateDataValueHandler = (0, _react.useCallback)(async function (path, value) {
    let {
      preventUpdate = undefined
    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    if (internalDataRef.current === _Provider.clearedData) {
      internalDataRef.current = {};
    }
    _jsonPointer.default.set(internalDataRef.current, path, value);
    if (!preventUpdate) {
      forceUpdate();
    }
  }, []);
  const removeSectionPath = (0, _react.useCallback)(data => {
    return pathSection && _jsonPointer.default.has(data, pathSection) ? _jsonPointer.default.get(data, pathSection) : data;
  }, [pathSection]);
  const getMountedData = (0, _react.useCallback)(data => {
    var _dataContextRef$curre;
    const mounterData = {};
    (_dataContextRef$curre = dataContextRef.current) === null || _dataContextRef$curre === void 0 ? void 0 : _dataContextRef$curre.mountedFieldsRef.current.forEach((field, path) => {
      if (field.isMounted && _jsonPointer.default.has(data, path)) {
        _jsonPointer.default.set(mounterData, path, _jsonPointer.default.get(data, path));
      }
    });
    return mounterData;
  }, []);
  (0, _useMountEffect.default)(() => {
    localDataRef.current = getMountedData(internalDataRef.current);
  });
  (0, _react.useMemo)(() => {
    if (localDataRef.current === _Provider.clearedData) {
      return;
    }
    let localData = data !== null && data !== void 0 ? data : defaultData;
    if (localData && pathSection && !_jsonPointer.default.has(localDataRef.current, pathSection)) {
      localData = moveValueToPath(pathSection, localData);
    }
    internalDataRef.current = Object.assign({}, localData || (0, _structuredClone.default)(dataOuter) || {}, localDataRef.current);
  }, [data, defaultData, pathSection, dataOuter, moveValueToPath]);
  const onCommit = (0, _react.useCallback)(async (data, additionalArgs) => {
    var _props$path;
    const mountedData = getMountedData(data);
    const path = (_props$path = props.path) !== null && _props$path !== void 0 ? _props$path : '/';
    const outerData = props.path && _jsonPointer.default.has(dataOuter, path) ? _jsonPointer.default.get(dataOuter, path) : dataOuter;
    localDataRef.current = mountedData;
    let isolatedData = (0, _structuredClone.default)(mountedData);
    if (typeof transformOnCommitProp === 'function') {
      isolatedData = transformOnCommitProp(isolatedData, outerData);
    }
    let stop = false;
    additionalArgs.preventCommit = () => stop = true;
    const commitData = removeSectionPath(isolatedData);
    const result = (0, _isAsync.isAsync)(onCommitProp) ? await (onCommitProp === null || onCommitProp === void 0 ? void 0 : onCommitProp(commitData, additionalArgs)) : onCommitProp === null || onCommitProp === void 0 ? void 0 : onCommitProp(commitData, additionalArgs);
    if (stop) {
      return;
    }
    await (handlePathChangeOuter === null || handlePathChangeOuter === void 0 ? void 0 : handlePathChangeOuter(path, Array.isArray(isolatedData) ? isolatedData : (0, _componentHelper.extendDeep)({}, outerData, isolatedData)));
    return result;
  }, [getMountedData, props.path, dataOuter, transformOnCommitProp, handlePathChangeOuter, onCommitProp, removeSectionPath]);
  const setIsolatedData = (0, _react.useCallback)(data => {
    localDataRef.current = data;
    internalDataRef.current = data;
  }, []);
  const onClear = (0, _react.useCallback)(() => {
    setIsolatedData(_Provider.clearedData);
    forceUpdate();
    onClearProp === null || onClearProp === void 0 ? void 0 : onClearProp();
  }, [onClearProp, setIsolatedData]);
  const providerProps = _objectSpread(_objectSpread({}, props), {}, {
    [defaultData ? 'defaultData' : 'data']: internalDataRef.current,
    onUpdateDataValue: onUpdateDataValueHandler,
    onPathChange: onPathChangeHandler,
    onCommit,
    onClear,
    isolate: true
  });
  return _react.default.createElement(_DataContext.Provider, providerProps, _react.default.createElement(_IsolationContext.default.Provider, {
    value: {
      preventUncommittedChanges,
      dataReference,
      resetDataAfterCommit,
      outerContext,
      setIsolatedData
    }
  }, _react.default.createElement(_DataContext.Context.Consumer, null, dataContext => {
    dataContextRef.current = dataContext;
    if (commitHandleRef) {
      commitHandleRef.current = dataContext === null || dataContext === void 0 ? void 0 : dataContext.handleSubmit;
    }
    return _IsolatedContainer || (_IsolatedContainer = _react.default.createElement(_IsolatedContainer2.default, null, children, " "));
  }), bubbleValidation && (_BubbleValidation || (_BubbleValidation = _react.default.createElement(BubbleValidation, null)))));
}
function BubbleValidation() {
  var _addSetShowAllErrorsR;
  const innerContext = (0, _react.useContext)(_DataContext.Context);
  const {
    outerContext
  } = (0, _react.useContext)(_IsolationContext.default);
  const {
    setShowAllErrors
  } = innerContext;
  const setShowAllErrorsNested = (0, _react.useCallback)(showAllErrors => {
    setShowAllErrors === null || setShowAllErrors === void 0 ? void 0 : setShowAllErrors(showAllErrors);
  }, [setShowAllErrors]);
  const {
    addSetShowAllErrorsRef
  } = outerContext || {};
  if (!(addSetShowAllErrorsRef !== null && addSetShowAllErrorsRef !== void 0 && (_addSetShowAllErrorsR = addSetShowAllErrorsRef.current) !== null && _addSetShowAllErrorsR !== void 0 && _addSetShowAllErrorsR.includes(setShowAllErrorsNested))) {
    addSetShowAllErrorsRef === null || addSetShowAllErrorsRef === void 0 ? void 0 : addSetShowAllErrorsRef.current.push(setShowAllErrorsNested);
  }
  (0, _useReportError.default)(innerContext.hasErrors() ? _IsolatedContainer2.isolationError : undefined, outerContext, 'isolation');
  return null;
}
IsolationProvider.CommitButton = _IsolationCommitButton.default;
IsolationProvider.ResetButton = _IsolationResetButton.default;
IsolationProvider.createDataReference = _IsolationDataReference.createDataReference;
IsolationProvider._supportsSpacingProps = undefined;
var _default = exports.default = IsolationProvider;
//# sourceMappingURL=Isolation.js.map