@availity/mui-spaces 0.1.0

package/dist/index.js

@@ -0,0 +1,456 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  INITIAL_STATE: () => INITIAL_STATE,
+  Spaces: () => Spaces,
+  SpacesContext: () => SpacesContext,
+  useSpaces: () => useSpaces,
+  useSpacesContext: () => useSpacesContext
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/Spaces.tsx
+var import_react = require("react");
+var import_react_query = require("@tanstack/react-query");
+
+// src/lib/spaces-data.tsx
+var import_api_axios = require("@availity/api-axios");
+var actions = {
+  SPACES: (currentState, { spaces, spacesByConfig, spacesByPayer }) => ({
+    previousSpacesMap: spaces,
+    previousSpacesByConfigMap: spacesByConfig,
+    previousSpacesByPayerMap: spacesByPayer,
+    error: void 0,
+    loading: false
+  }),
+  ERROR: (state, { error }) => __spreadProps(__spreadValues({}, state), {
+    loading: false,
+    error
+  }),
+  LOADING: (state, { loading }) => __spreadProps(__spreadValues({}, state), {
+    loading: loading !== void 0 ? loading : !state.loading
+  })
+};
+var spacesReducer = (state, action) => {
+  const { type } = action;
+  return actions[type](state, action);
+};
+var normalizeSpaces = (spaces) => {
+  let spacesToReduce = spaces;
+  if (Array.isArray(spaces[0])) {
+    spacesToReduce = spaces[0];
+  }
+  const pairFields = ["images", "metadata", "colors", "icons", "mapping"];
+  return spacesToReduce.reduce((accum, spc) => {
+    var _b;
+    if (!spc)
+      return accum;
+    const _a = spc, { images, metadata, colors, icons, mapping } = _a, rest = __objRest(_a, ["images", "metadata", "colors", "icons", "mapping"]);
+    const normalizedSpace = __spreadValues({}, rest);
+    for (const field of pairFields) {
+      if (spc[field] && Array.isArray(spc[field])) {
+        normalizedSpace[field] = (_b = spc[field]) == null ? void 0 : _b.reduce((_accum, { name, value }) => {
+          _accum[name] = value;
+          return _accum;
+        }, {});
+      }
+    }
+    accum.push(normalizedSpace);
+    return accum;
+  }, []);
+};
+var fetchSpaces = (_0) => __async(void 0, [_0], function* ({ query, clientId, variables }) {
+  const {
+    data: {
+      data: { configurationPagination }
+    }
+  } = yield import_api_axios.avWebQLApi.create(
+    {
+      query,
+      variables: __spreadValues({}, variables)
+    },
+    { headers: { "X-Client-ID": clientId } }
+  );
+  const {
+    pageInfo: { currentPage, hasNextPage },
+    items
+  } = configurationPagination;
+  return {
+    items,
+    currentPage,
+    hasNextPage
+  };
+});
+var fetchAllSpaces = (_0) => __async(void 0, [_0], function* ({
+  query,
+  clientId,
+  variables,
+  _spaces = []
+}) {
+  const { items, currentPage, hasNextPage } = yield fetchSpaces({ query, clientId, variables });
+  _spaces.push(...items);
+  if (hasNextPage) {
+    const vars = __spreadProps(__spreadValues({}, variables), {
+      page: currentPage + 1
+    });
+    return fetchAllSpaces({ query, clientId, variables: vars, _spaces });
+  }
+  return _spaces;
+});
+
+// src/lib/configurationFindMany.tsx
+var configurationFindMany_default = `query configurationFindMany($ids: [String!], $payerIDs: [ID!], $types: [TypeEnum!]) {
+  configurationPagination(filter: { ids: $ids, payerIds: $payerIDs, types: $types }) {
+    pageInfo {
+      hasNextPage
+      currentPage
+    }
+    items {
+      ... on Configuration {
+        configurationId
+        name
+        shortName
+        type
+        activeDate
+        isNew
+        description
+        payerIDs
+        parentIDs
+        metadataPairs {
+          name
+          value
+        }
+      }
+
+      ... on Node {
+        id
+      }
+
+      ... on Alert {
+        link {
+          text
+          target
+          url
+        }
+      }
+
+      ... on Container {
+        link {
+          text
+          target
+          url
+        }
+        images {
+          tile
+          promotional
+          logo
+          billboard
+        }
+      }
+
+      ... on PayerSpace {
+        link {
+          text
+          target
+          url
+        }
+        images {
+          tile
+          logo
+          billboard
+        }
+        url
+      }
+
+      ... on Application {
+        link {
+          text
+          target
+          url
+        }
+      }
+
+      ... on Resource {
+        link {
+          text
+          target
+          url
+        }
+      }
+
+      ... on Navigation {
+        icons {
+          dashboard
+          navigation
+        }
+        images {
+          promotional
+        }
+      }
+
+      ... on Learning {
+        images {
+          promotional
+        }
+      }
+
+      ... on Proxy {
+        url
+      }
+
+      ... on File {
+        url
+      }
+    }
+  }
+}`;
+
+// src/lib/Spaces.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var INITIAL_STATE = {
+  loading: true
+};
+var SpacesContext = (0, import_react.createContext)(INITIAL_STATE);
+var useSpacesContext = () => (0, import_react.useContext)(SpacesContext);
+var Spaces = ({
+  query = configurationFindMany_default,
+  variables = { types: ["PAYERSPACE"] },
+  clientId,
+  children,
+  payerIds,
+  spaceIds,
+  spaces: spacesFromProps
+}) => {
+  const [{ previousSpacesMap, previousSpacesByConfigMap, previousSpacesByPayerMap, loading, error }, dispatch] = (0, import_react.useReducer)(spacesReducer, INITIAL_STATE);
+  const spacesMap = new Map(previousSpacesMap);
+  const configIdsMap = new Map(previousSpacesByConfigMap);
+  const payerIdsMap = new Map(previousSpacesByPayerMap);
+  const spaceIdsToQuery = /* @__PURE__ */ new Set();
+  const payerIdsToQuery = /* @__PURE__ */ new Set();
+  if (spacesFromProps && spacesFromProps.length > 0) {
+    for (const space of spacesFromProps) {
+      if (space.id && !spacesMap.has(space.id)) {
+        spacesMap.set(space.id, space);
+      }
+      if (space.configurationId && !configIdsMap.has(space.configurationId)) {
+        configIdsMap.set(space.configurationId, space);
+      }
+      if (space.payerIDs) {
+        for (const pId of space.payerIDs) {
+          const currentSpacesForPayerId = payerIdsMap.get(pId);
+          if (currentSpacesForPayerId) {
+            payerIdsMap.set(pId, [...currentSpacesForPayerId, space]);
+          } else {
+            payerIdsMap.set(pId, [space]);
+          }
+        }
+      }
+    }
+  }
+  if (spaceIds && spaceIds.length > 0) {
+    for (const id of spaceIds) {
+      if (!(spacesMap.has(id) || configIdsMap.has(id))) {
+        spaceIdsToQuery.add(id);
+      }
+    }
+  }
+  if (payerIds && payerIds.length > 0) {
+    for (const pid of payerIds) {
+      if (!payerIdsMap.has(pid)) {
+        payerIdsToQuery.add(pid);
+      }
+    }
+  }
+  const spaceIdVars = __spreadProps(__spreadValues({}, variables), { ids: [...spaceIdsToQuery.keys()] });
+  const payerIdVars = __spreadProps(__spreadValues({}, variables), { payerIds: [...payerIdsToQuery.keys()] });
+  const [
+    { data: spacesBySpaceIds, isFetching: isLoadingBySpaceIds, error: errorBySpaceIds },
+    { data: spacesByPayerIds, isFetching: isLoadingByPayerIds, error: errorByPayerIds }
+  ] = (0, import_react_query.useQueries)({
+    queries: [
+      {
+        queryKey: ["id", spaceIdVars],
+        queryFn: () => fetchAllSpaces({ query, clientId, variables: spaceIdVars }),
+        enabled: spaceIdsToQuery.size > 0
+      },
+      {
+        queryKey: ["id", payerIdVars],
+        queryFn: () => fetchAllSpaces({ query, clientId, variables: payerIdVars }),
+        enabled: payerIdsToQuery.size > 0
+      }
+    ]
+  });
+  (0, import_react.useEffect)(() => {
+    if (errorByPayerIds || errorBySpaceIds) {
+      dispatch({
+        type: "ERROR",
+        error: (errorByPayerIds == null ? void 0 : errorByPayerIds.message) || (errorBySpaceIds == null ? void 0 : errorBySpaceIds.message),
+        loading: false
+      });
+    }
+  }, [errorByPayerIds, errorBySpaceIds]);
+  (0, import_react.useEffect)(() => {
+    dispatch({
+      type: "LOADING",
+      loading: true
+    });
+    if (spaceIdsToQuery.size === 0 && payerIdsToQuery.size === 0) {
+      dispatch({
+        type: "LOADING",
+        loading: false
+      });
+      return;
+    }
+    if (spacesBySpaceIds) {
+      for (const space of spacesBySpaceIds) {
+        if (!spacesMap.has(space.id)) {
+          spacesMap.set(space.id, space);
+        }
+        if (!configIdsMap.has(space.configurationId)) {
+          configIdsMap.set(space.configurationId, space);
+        }
+        if (space.payerIDs) {
+          for (const pId of space.payerIDs) {
+            const currentSpacesForPayerId = payerIdsMap.get(pId);
+            if (currentSpacesForPayerId) {
+              payerIdsMap.set(pId, [...currentSpacesForPayerId, space]);
+            } else {
+              payerIdsMap.set(pId, [space]);
+            }
+          }
+        }
+      }
+    }
+    if (payerIdsToQuery.size > 0) {
+      if (spacesByPayerIds) {
+        for (const space of spacesByPayerIds) {
+          if (!spacesMap.has(space.id)) {
+            spacesMap.set(space.id, space);
+          }
+          if (!configIdsMap.has(space.configurationId)) {
+            configIdsMap.set(space.configurationId, space);
+          }
+          if (space.payerIDs) {
+            for (const pId of space.payerIDs) {
+              const currentSpacesForPayerId = payerIdsMap.get(pId);
+              if (currentSpacesForPayerId) {
+                payerIdsMap.set(pId, [...currentSpacesForPayerId, space]);
+              } else {
+                payerIdsMap.set(pId, [space]);
+              }
+            }
+          }
+        }
+      }
+    }
+    dispatch({
+      type: "SPACES",
+      spaces: spacesMap,
+      spacesByConfig: configIdsMap,
+      spacesByPayer: payerIdsMap,
+      loading: false
+    });
+  }, [spacesBySpaceIds, spacesByPayerIds, payerIds, spaceIds]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    SpacesContext.Provider,
+    {
+      children,
+      value: {
+        spaces: spacesMap,
+        spacesByConfig: configIdsMap,
+        spacesByPayer: payerIdsMap,
+        loading: loading || isLoadingByPayerIds || isLoadingBySpaceIds,
+        error
+      }
+    }
+  );
+};
+var useSpaces = (...ids) => {
+  const { spaces, spacesByConfig, spacesByPayer } = useSpacesContext();
+  const idsIsEmpty = !ids || ids.length === 0;
+  const callerIsExpectingFirstSpace = (ids == null ? void 0 : ids.length) === 1 && ids[0] === void 0;
+  const shouldReturnAllSpaces = idsIsEmpty || callerIsExpectingFirstSpace;
+  if (shouldReturnAllSpaces) {
+    console.warn(`You did not pass in an ID to find a space, returning all spaces.`);
+    return spaces && normalizeSpaces([...spaces.values()]);
+  }
+  const matchedSpaces = ids.map((id) => (spaces == null ? void 0 : spaces.get(id)) || (spacesByConfig == null ? void 0 : spacesByConfig.get(id)) || (spacesByPayer == null ? void 0 : spacesByPayer.get(id)));
+  const normalized = normalizeSpaces(matchedSpaces);
+  return normalized;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INITIAL_STATE,
+  Spaces,
+  SpacesContext,
+  useSpaces,
+  useSpacesContext
+});