@rest-hooks/ssr/dist/index.js

Server Side Rendering helpers for Rest Hooks

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var react = require('react');
var redux = require('@rest-hooks/redux');
var redux$1 = require('redux');
var react$1 = require('@rest-hooks/react');

function unwrapExports (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var jsx = createCommonjsModule(function (module) {
var REACT_ELEMENT_TYPE;
function _createRawReactElement(type, props, key, children) {
  REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103);
  var defaultProps = type && type.defaultProps,
    childrenLength = arguments.length - 3;
  if (props || 0 === childrenLength || (props = {
    children: void 0
  }), 1 === childrenLength) props.children = children;else if (childrenLength > 1) {
    for (var childArray = new Array(childrenLength), i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 3];
    props.children = childArray;
  }
  if (props && defaultProps) for (var propName in defaultProps) void 0 === props[propName] && (props[propName] = defaultProps[propName]);else props || (props = defaultProps || {});
  return {
    $$typeof: REACT_ELEMENT_TYPE,
    type: type,
    key: void 0 === key ? null : "" + key,
    ref: null,
    props: props,
    _owner: null
  };
}
module.exports = _createRawReactElement, module.exports.__esModule = true, module.exports["default"] = module.exports;
});

var _jsx = unwrapExports(jsx);

const {
  createReducer,
  initialState: initialState$1,
  applyManager
} = redux.__INTERNAL__;
function createPersistedStore(managers) {
  var _managers;
  const controller = new redux.Controller();
  managers = (_managers = managers) != null ? _managers : [new redux.NetworkManager()];
  const nm = managers.find(m => m instanceof redux.NetworkManager);
  if (nm === undefined) throw new Error('managers must include a NetworkManager');
  const reducer = createReducer(controller);
  const enhancer = redux$1.applyMiddleware(...applyManager(managers, controller), redux.PromiseifyMiddleware);
  const store = redux$1.createStore(reducer, initialState$1, enhancer);
  managers.forEach(manager => manager.init == null ? void 0 : manager.init(store.getState()));
  const selector = state => state;
  const getState = () => selector(store.getState());
  let firstRender = true;
  function useReadyCacheState() {
    const inFlightFetches = nm.allSettled();
    if (inFlightFetches) {
      firstRender = false;
      throw inFlightFetches;
    }
    if (firstRender) {
      firstRender = false;
      throw new Promise(resolve => setTimeout(resolve, 10));
    }
    return react.useSyncExternalStore(store.subscribe, getState, getState);
  }
  function ServerCacheProvider({
    children
  }) {
    return /*#__PURE__*/_jsx(redux.ExternalCacheProvider, {
      store: store,
      selector: selector,
      controller: controller
    }, void 0, children);
  }
  return [ServerCacheProvider, useReadyCacheState, controller, store];
}

const {
  initialState
} = react$1.__INTERNAL__;
const awaitInitialData = (id = 'rest-hooks-data') => {
  return new Promise((resolve, reject) => {
    let el;
    if (el = document.getElementById(id)) {
      resolve(getDataFromEl(el, id));
      return;
    }
    document.addEventListener('DOMContentLoaded', () => {
      el = document.getElementById(id);
      if (el) resolve(getDataFromEl(el, id));else reject(new Error('failed to find DOM with rest hooks state'));
    });
  });
};
const getInitialData = (id = 'rest-hooks-data') => {
  const el = document.getElementById(id);
  if (!el) return initialState;
  return getDataFromEl(el, id);
};
function getDataFromEl(el, key) {
  if (el.text === undefined) {
    console.error(`#${key} is completely empty. This could be due to CSP issues.`);
  }
  return el != null && el.text ? JSON.parse(el == null ? void 0 : el.text) : undefined;
}

const ServerData = ({
  data,
  nonce,
  id
}) => {
  try {
    const encoded = JSON.stringify(data);
    return /*#__PURE__*/_jsx("script", {
      id: id,
      type: "application/json",
      dangerouslySetInnerHTML: {
        __html: encoded
      },
      nonce: nonce
    });
  } catch (e) {
    console.error(`Error serializing json for ${id}`);
    console.error(e);
    return null;
  }
};
ServerData.defaultProps = {
  id: 'rest-hooks-data'
};
var ServerData$1 = ServerData;

function createServerDataComponent(useReadyCacheState, id = 'rest-hooks-data') {
  const ServerDataAsync = ({
    nonce
  }) => {
    const data = useReadyCacheState();
    return /*#__PURE__*/_jsx(ServerData$1, {
      data: data,
      id: id,
      nonce: nonce
    });
  };
  const ServerDataComponent = ({
    nonce
  }) => /*#__PURE__*/_jsx(react.Suspense, {}, void 0, /*#__PURE__*/_jsx(ServerDataAsync, {
    nonce: nonce
  }));
  return ServerDataComponent;
}

Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
  return Object.prototype.hasOwnProperty.call(it, key);
};

exports.ServerData = ServerData$1;
exports.awaitInitialData = awaitInitialData;
exports.createPersistedStore = createPersistedStore;
exports.createServerDataComponent = createServerDataComponent;
exports.getInitialData = getInitialData;