@oimdb/react/dist/index.cjs

React integration for OIMDB - Hooks for selection and subscription with external storage

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  OIMRICollectionsContext: () => OIMRICollectionsContext,
  OIMRICollectionsProvider: () => OIMRICollectionsProvider,
  createOIMCollectionsContext: () => createOIMCollectionsContext,
  useOIMCollectionsContext: () => useOIMCollectionsContext,
  useSelectEntitiesByIndexKeyArrayBased: () => useSelectEntitiesByIndexKeyArrayBased,
  useSelectEntitiesByIndexKeySetBased: () => useSelectEntitiesByIndexKeySetBased,
  useSelectEntitiesByIndexKeysArrayBased: () => useSelectEntitiesByIndexKeysArrayBased,
  useSelectEntitiesByIndexKeysSetBased: () => useSelectEntitiesByIndexKeysSetBased,
  useSelectEntitiesByPks: () => useSelectEntitiesByPks,
  useSelectEntityByPk: () => useSelectEntityByPk,
  useSelectPksByIndexKeyArrayBased: () => useSelectPksByIndexKeyArrayBased,
  useSelectPksByIndexKeySetBased: () => useSelectPksByIndexKeySetBased,
  useSelectPksByIndexKeysArrayBased: () => useSelectPksByIndexKeysArrayBased,
  useSelectPksByIndexKeysSetBased: () => useSelectPksByIndexKeysSetBased
});
module.exports = __toCommonJS(index_exports);

// src/hooks/index.ts
var import_react = require("react");
var import_react2 = require("react");
var EMPTY_ARRAY = [];
var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
  const prevKeysRef = (0, import_react.useRef)();
  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
  if (!keysAreEqual) {
    prevKeysRef.current = keys;
  }
  const snapshotValueRef = (0, import_react.useRef)();
  const subscribe = (0, import_react.useMemo)(() => {
    snapshotValueRef.current = keys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
    return (onStoreChange) => {
      const prevKeys = prevKeysRef.current;
      if (!prevKeys) {
        return () => {
        };
      }
      const updateSnapshot = () => {
        snapshotValueRef.current = keys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
        onStoreChange();
      };
      reactiveIndex.updateEventEmitter.subscribeOnKeys(
        prevKeys,
        updateSnapshot
      );
      return () => {
        reactiveIndex.updateEventEmitter.unsubscribeFromKeys(
          prevKeys,
          updateSnapshot
        );
      };
    };
  }, [prevKeysRef.current, reactiveIndex.updateEventEmitter]);
  const getSnapshot = (0, import_react.useMemo)(() => {
    return () => {
      return snapshotValueRef.current;
    };
  }, []);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
  const getSnapshot = (0, import_react.useMemo)(() => {
    return () => {
      return reactiveIndex.getPksByKey(key);
    };
  }, [key, reactiveIndex]);
  const subscribe = (0, import_react.useMemo)(() => {
    return (onStoreChange) => {
      reactiveIndex.updateEventEmitter.subscribeOnKey(key, onStoreChange);
      return () => {
        reactiveIndex.updateEventEmitter.unsubscribeFromKey(
          key,
          onStoreChange
        );
      };
    };
  }, [key, reactiveIndex.updateEventEmitter]);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
  const prevKeysRef = (0, import_react.useRef)();
  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
  if (!keysAreEqual) {
    prevKeysRef.current = keys;
  }
  const snapshotValueRef = (0, import_react.useRef)();
  const subscribe = (0, import_react.useMemo)(() => {
    snapshotValueRef.current = keys.map((key) => reactiveIndex.getPksByKey(key)).flat();
    return (onStoreChange) => {
      const prevKeys = prevKeysRef.current;
      if (!prevKeys) {
        return () => {
        };
      }
      const updateSnapshot = () => {
        snapshotValueRef.current = keys.map((key) => reactiveIndex.getPksByKey(key)).flat();
        onStoreChange();
      };
      reactiveIndex.updateEventEmitter.subscribeOnKeys(
        prevKeys,
        updateSnapshot
      );
      return () => {
        reactiveIndex.updateEventEmitter.unsubscribeFromKeys(
          prevKeys,
          updateSnapshot
        );
      };
    };
  }, [prevKeysRef.current, reactiveIndex.updateEventEmitter]);
  const getSnapshot = (0, import_react.useMemo)(() => {
    return () => {
      return snapshotValueRef.current;
    };
  }, []);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
  const prevKeyRef = (0, import_react.useRef)();
  const keyAreEqual = prevKeyRef.current === key;
  if (!keyAreEqual) {
    prevKeyRef.current = key;
  }
  const snapshotValueRef = (0, import_react.useRef)();
  const subscribe = (0, import_react.useMemo)(() => {
    snapshotValueRef.current = reactiveIndex.getPksByKey(key);
    return (onStoreChange) => {
      const prevKey = prevKeyRef.current;
      if (!prevKey) {
        return () => {
        };
      }
      const updateSnapshot = () => {
        snapshotValueRef.current = reactiveIndex.getPksByKey(prevKey);
        onStoreChange();
      };
      reactiveIndex.updateEventEmitter.subscribeOnKey(
        prevKey,
        updateSnapshot
      );
      return () => {
        reactiveIndex.updateEventEmitter.unsubscribeFromKey(
          prevKey,
          updateSnapshot
        );
      };
    };
  }, [key, reactiveIndex.updateEventEmitter]);
  const getSnapshot = (0, import_react.useMemo)(() => {
    return () => {
      return snapshotValueRef.current;
    };
  }, []);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
var useSelectEntityByPk = (reactiveCollection, pk) => {
  const getSnapshot = (0, import_react.useMemo)(
    () => () => reactiveCollection.getOneByPk(pk),
    [pk, reactiveCollection]
  );
  const subscribe = (0, import_react.useMemo)(() => {
    return (onStoreChange) => {
      reactiveCollection.updateEventEmitter.subscribeOnKey(
        pk,
        onStoreChange
      );
      return () => {
        reactiveCollection.updateEventEmitter.unsubscribeFromKey(
          pk,
          onStoreChange
        );
      };
    };
  }, [pk, reactiveCollection.updateEventEmitter]);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
function arraysEqual(a, b) {
  if (a === b) return true;
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}
var useSelectEntitiesByPks = (reactiveCollection, pks) => {
  const prevPksRef = (0, import_react.useRef)();
  const pksAreEqual = arraysEqual(prevPksRef.current || EMPTY_ARRAY, pks);
  if (!pksAreEqual) {
    prevPksRef.current = pks;
  }
  const snapshotRef = (0, import_react.useRef)();
  const subscribe = (0, import_react.useMemo)(() => {
    snapshotRef.current = pks.map((pk) => reactiveCollection.getOneByPk(pk));
    return (onStoreChange) => {
      const prevPks = prevPksRef.current;
      if (!prevPks) {
        return () => {
        };
      }
      const updateSnapshot = () => {
        snapshotRef.current = prevPks.map(
          (pk) => reactiveCollection.getOneByPk(pk)
        );
        onStoreChange();
      };
      reactiveCollection.updateEventEmitter.subscribeOnKeys(
        prevPks,
        updateSnapshot
      );
      return () => {
        reactiveCollection.updateEventEmitter.unsubscribeFromKeys(
          prevPks,
          updateSnapshot
        );
      };
    };
  }, [prevPksRef.current, reactiveCollection.updateEventEmitter]);
  const getSnapshot = (0, import_react.useMemo)(() => {
    return () => {
      return snapshotRef.current;
    };
  }, []);
  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
  return snapshot;
};
var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, key) => {
  const pks = useSelectPksByIndexKeySetBased(reactiveIndex, key);
  const pksArray = (0, import_react.useMemo)(
    () => pks ? Array.from(pks) : EMPTY_ARRAY,
    [pks]
  );
  return useSelectEntitiesByPks(reactiveCollection, pksArray);
};
var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, keys) => {
  const pks = useSelectPksByIndexKeysSetBased(reactiveIndex, keys);
  const pksArray = (0, import_react.useMemo)(
    () => pks ? Array.from(pks) : EMPTY_ARRAY,
    [pks]
  );
  return useSelectEntitiesByPks(reactiveCollection, pksArray);
};
var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex, key) => {
  const pks = useSelectPksByIndexKeyArrayBased(reactiveIndex, key);
  return useSelectEntitiesByPks(
    reactiveCollection,
    pks || EMPTY_ARRAY
  );
};
var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex, keys) => {
  const pks = useSelectPksByIndexKeysArrayBased(reactiveIndex, keys) || EMPTY_ARRAY;
  return useSelectEntitiesByPks(reactiveCollection, pks);
};

// src/context/index.tsx
var import_react3 = require("react");
var import_jsx_runtime = require("react/jsx-runtime");
var OIMRICollectionsContext = (0, import_react3.createContext)(
  {}
);
function createOIMCollectionsContext() {
  return (0, import_react3.createContext)({});
}
function OIMRICollectionsProvider({ collections, children, context }) {
  const ContextToUse = context || OIMRICollectionsContext;
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContextToUse.Provider, { value: collections, children });
}
function useOIMCollectionsContext(context) {
  const contextToUse = context || OIMRICollectionsContext;
  const collections = (0, import_react3.useContext)(contextToUse);
  if (!collections || Object.keys(collections).length === 0) {
    throw new Error(
      "useOIMCollectionsContext must be used within an OIMRICollectionsProvider"
    );
  }
  return collections;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  OIMRICollectionsContext,
  OIMRICollectionsProvider,
  createOIMCollectionsContext,
  useOIMCollectionsContext,
  useSelectEntitiesByIndexKeyArrayBased,
  useSelectEntitiesByIndexKeySetBased,
  useSelectEntitiesByIndexKeysArrayBased,
  useSelectEntitiesByIndexKeysSetBased,
  useSelectEntitiesByPks,
  useSelectEntityByPk,
  useSelectPksByIndexKeyArrayBased,
  useSelectPksByIndexKeySetBased,
  useSelectPksByIndexKeysArrayBased,
  useSelectPksByIndexKeysSetBased
});