@dnb/eufemia/shared/helpers/useSharedState.js

DNB Eufemia Design System UI Library

"use client";

import _pushInstanceProperty from "core-js-pure/stable/instance/push.js";
import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
import useMounted from "./useMounted.js";
import useMountEffect from "./useMountEffect.js";
import { useIsomorphicLayoutEffect as useLayoutEffect } from "./useIsomorphicLayoutEffect.js";
export function useWeakSharedState(id, initialData = undefined, onChange = null) {
  return useSharedState(id, initialData, onChange, {
    weak: true
  });
}
export function useSharedState(id, initialData = undefined, onChange = null, {
  weak = false
} = {}) {
  var _sharedState$get2;
  const [, forceUpdate] = useReducer(() => ({}), {});
  const hasMountedRef = useMounted();
  const waitForMountedRef = useRef(false);
  const instanceRef = useRef({});
  const forceRerender = useCallback(() => {
    if (hasMountedRef.current) {
      forceUpdate();
    } else {
      waitForMountedRef.current = true;
    }
  }, [hasMountedRef]);
  const shouldSync = useCallback(fn => {
    if (instanceRef.current === (fn === null || fn === void 0 ? void 0 : fn['ref'])) {
      return false;
    }
  }, []);
  useMountEffect(() => {
    if (waitForMountedRef.current) {
      forceUpdate();
    }
  });
  const sharedState = useMemo(() => {
    if (id) {
      return createSharedState(id, initialData, {
        shouldSync
      });
    }
  }, [id, initialData, shouldSync]);
  const sharedAttachment = useMemo(() => {
    if (id) {
      return createSharedState(createReferenceKey(id, 'oc'), {
        onChange
      }, {
        shouldSync
      });
    }
  }, [id, onChange, shouldSync]);
  const syncAttachment = useCallback(newData => {
    if (id) {
      var _sharedAttachment$dat, _sharedAttachment$dat2;
      (_sharedAttachment$dat = sharedAttachment.data) === null || _sharedAttachment$dat === void 0 || (_sharedAttachment$dat2 = _sharedAttachment$dat.onChange) === null || _sharedAttachment$dat2 === void 0 || _sharedAttachment$dat2.call(_sharedAttachment$dat, newData);
    }
  }, [id, sharedAttachment]);
  const update = useCallback((newData, opts) => {
    if (id) {
      sharedState.update(newData, opts);
    }
  }, [id, sharedState]);
  const get = useCallback(() => {
    if (id) {
      var _sharedState$get;
      return sharedState === null || sharedState === void 0 || (_sharedState$get = sharedState.get) === null || _sharedState$get === void 0 ? void 0 : _sharedState$get.call(sharedState);
    }
  }, [id, sharedState]);
  const set = useCallback(newData => {
    if (id) {
      sharedState.set(newData);
      syncAttachment(newData);
    }
  }, [id, sharedState, syncAttachment]);
  const extend = useCallback((newData, opts) => {
    if (id) {
      sharedState.extend(newData, opts);
      syncAttachment(newData);
    }
  }, [id, sharedState, syncAttachment]);
  useLayoutEffect(() => {
    if (!id) {
      return;
    }
    forceRerender['ref'] = instanceRef.current;
    sharedState.subscribe(forceRerender);
    return () => {
      sharedState.unsubscribe(forceRerender);
      if (weak && sharedState.subscribersRef.current.length === 0) {
        sharedState.update(undefined);
      }
    };
  }, [forceRerender, id, onChange, sharedState, weak]);
  useEffect(() => {
    var _sharedAttachment$dat3;
    if (id && onChange && !((_sharedAttachment$dat3 = sharedAttachment.data) !== null && _sharedAttachment$dat3 !== void 0 && _sharedAttachment$dat3.onChange)) {
      sharedAttachment.set({
        onChange
      });
    }
  }, [id, onChange, sharedAttachment]);
  return {
    get,
    data: sharedState === null || sharedState === void 0 || (_sharedState$get2 = sharedState.get) === null || _sharedState$get2 === void 0 ? void 0 : _sharedState$get2.call(sharedState),
    hadInitialData: sharedState === null || sharedState === void 0 ? void 0 : sharedState.hadInitialData,
    update,
    set,
    extend
  };
}
const sharedStates = new Map();
export function createSharedState(id, initialData, {
  shouldSync = null
} = {}) {
  if (!sharedStates.get(id)) {
    const subscribersRef = {
      current: []
    };
    const sync = (opts = {}) => {
      subscribersRef.current.forEach(subscriber => {
        const syncNow = opts.preventSyncOfSameInstance ? (shouldSync === null || shouldSync === void 0 ? void 0 : shouldSync(subscriber)) !== false : true;
        if (syncNow) {
          subscriber();
        }
      });
    };
    const get = () => sharedStates.get(id).data;
    const set = newData => {
      sharedStates.get(id).data = newData === undefined ? undefined : {
        ...newData
      };
    };
    const update = (newData, opts) => {
      set(newData);
      sync(opts);
    };
    const extend = (newData, opts) => {
      sharedStates.get(id).data = {
        ...sharedStates.get(id).data,
        ...newData
      };
      sync(opts);
    };
    const subscribe = subscriber => {
      if (!subscribersRef.current.includes(subscriber)) {
        var _context;
        _pushInstanceProperty(_context = subscribersRef.current).call(_context, subscriber);
      }
    };
    const unsubscribe = subscriber => {
      subscribersRef.current = subscribersRef.current.filter(sub => sub !== subscriber);
    };
    sharedStates.set(id, {
      data: undefined,
      get,
      set,
      extend,
      update,
      subscribe,
      unsubscribe,
      hadInitialData: Boolean(initialData),
      subscribersRef
    });
    if (initialData) {
      extend(initialData);
    }
  } else if (sharedStates.get(id).data === undefined && initialData !== undefined) {
    sharedStates.get(id).data = {
      ...initialData
    };
  }
  return sharedStates.get(id);
}
export function createReferenceKey(ref1, ref2) {
  if (!cache.has(ref1)) {
    cache.set(ref1, new Map());
  }
  const innerMap = cache.get(ref1);
  if (!innerMap.has(ref2)) {
    innerMap.set(ref2, {});
  }
  return innerMap.get(ref2);
}
const cache = new Map();
//# sourceMappingURL=useSharedState.js.map