google-maps-js-api-react/_chunks/chunk-QWMSBSOL.cjs

Fast, tree-shakable, and light-weight React components and hooks for integrating Google Maps API functionality

'use strict';

var chunkLHLLIGUT_cjs = require('./chunk-LHLLIGUT.cjs');
var react = require('react');
var useConst = require('react-helpful-utils/useConst');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var useConst__default = /*#__PURE__*/_interopDefault(useConst);

var useHandlersAndProps = (props, connectedPairs, isKeyOmitted) => useConst__default.default(() => {
  const isTriggeredBySetStateSet = /* @__PURE__ */ new Set();
  const handlersList = [];
  const propsList = [];
  let isUpdated;
  let instance;
  for (const key in props) {
    if (!isKeyOmitted(key)) {
      (key.startsWith("on") ? handlersList : propsList).push(key);
    }
  }
  return (props2) => {
    for (let i = propsList.length; i--; ) {
      const key = propsList[i];
      const value = props2[key];
      react.useLayoutEffect(() => {
        if (isUpdated) {
          isTriggeredBySetStateSet.add(key);
          instance.setOptions({ [key]: value });
        }
      }, [value]);
    }
    if (propsList.length) {
      react.useLayoutEffect(() => {
        isUpdated = true;
        return () => {
          isUpdated = false;
        };
      }, []);
    }
    for (let i = handlersList.length; i--; ) {
      const key = handlersList[i];
      const value = props2[key];
      react.useEffect(() => {
        if (value) {
          const eventName = (key.endsWith("Changed") ? key.slice(2, -7) + chunkLHLLIGUT_cjs.CHANGED : key.slice(2)).toLowerCase();
          let fn = value;
          if (connectedPairs.has(eventName)) {
            const dependBy = connectedPairs.get(eventName);
            const boundFn = fn.bind(instance);
            if (dependBy in props2) {
              isTriggeredBySetStateSet.delete(dependBy);
              fn = () => {
                if (!isTriggeredBySetStateSet.delete(dependBy)) {
                  boundFn(instance.get(dependBy));
                }
              };
            } else if (fn.length) {
              fn = () => {
                boundFn(instance.get(dependBy));
              };
            }
          }
          const listener = instance.addListener(eventName, fn);
          return () => listener.remove();
        }
      }, [value]);
    }
    return (_instance) => {
      instance = _instance;
    };
  };
})(props);
var useHandlersAndProps_default = useHandlersAndProps;

// src/utils/getConnectedEventsAndProps.ts
var getConnectedEventsAndProps = (arr) => {
  const connectedEventsAndProps = /* @__PURE__ */ new Map();
  if (arr) {
    for (let i = 0; i < arr.length; i++) {
      const item = arr[i];
      connectedEventsAndProps.set(
        item.toLowerCase() + chunkLHLLIGUT_cjs.CHANGED,
        item
      );
    }
  }
  return connectedEventsAndProps;
};
var getConnectedEventsAndProps_default = getConnectedEventsAndProps;

// src/utils/handleHas.ts
var handleHas = (keys) => {
  const set = new Set(keys);
  return set.has.bind(set);
};
var handleHas_default = handleHas;

exports.getConnectedEventsAndProps_default = getConnectedEventsAndProps_default;
exports.handleHas_default = handleHas_default;
exports.useHandlersAndProps_default = useHandlersAndProps_default;
//# sourceMappingURL=chunk-QWMSBSOL.cjs.map
//# sourceMappingURL=chunk-QWMSBSOL.cjs.map