react-use-object-state/index.es.js

React hooks to create stateful API's for reusable object patterns

import { useState, useMemo } from 'react';

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

function __rest(s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
}

function __spreadArrays() {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
}

var useObjectState = function (apiFactory, initialState) {
  var _a = useState(initialState),
      state = _a[0],
      setState = _a[1];

  return __assign(__assign({}, useMemo(function () {
    return apiFactory(setState);
  }, [apiFactory, setState])), {
    state: state,
    setState: setState
  });
};

var anchorElStateFactory = function (setState) {
  return {
    clearAnchorEl: function () {
      return setState(null);
    },
    setAnchorEl: function (event) {
      setState(event.currentTarget);
    }
  };
};
var useAnchorElState = function (initialValue) {
  var _a = useObjectState(anchorElStateFactory, initialValue),
      anchorEl = _a.state,
      setState = _a.setState,
      args = __rest(_a, ["state", "setState"]);

  return __assign({
    anchorEl: anchorEl
  }, args);
};

var deleteAt = function (index) {
  return function (state) {
    if (index >= 0 && index < state.length) {
      return __spreadArrays(state.slice(0, index), state.slice(index + 1, state.length));
    }

    return state;
  };
};
var clear = function () {
  return [];
};
var pop = function (state) {
  if (state.length > 0) {
    return __spreadArrays(state.slice(0, state.length - 1));
  }

  return state;
};
var push = function (val) {
  return function (state) {
    return __spreadArrays(state, val);
  };
};
var shift = function (state) {
  if (state.length > 0) {
    return deleteAt(0)(state);
  }

  return state;
};
var unshift = function (val) {
  return function (state) {
    return __spreadArrays(val, state);
  };
};
var reverse = function (state) {
  return __spreadArrays(state.reverse());
};
var insertAt = function (val, index) {
  return function (state) {
    if (index >= 0 && index < state.length) {
      return __spreadArrays(state.slice(0, index), [val], state.slice(index));
    }

    return state;
  };
};
var upsertAt = function (val, index) {
  return function (state) {
    if (index >= 0 && index < state.length) {
      var stateCopy = state.slice();
      stateCopy[index] = val;
      return stateCopy;
    }

    return state;
  };
};

var arrayStateFactory = function (setState) {
  return {
    clear: function () {
      return setState(clear);
    },
    reverse: function () {
      return setState(reverse);
    },
    pop: function () {
      return setState(pop);
    },
    push: function () {
      var val = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        val[_i] = arguments[_i];
      }

      return setState(push(val));
    },
    shift: function () {
      return setState(shift);
    },
    unshift: function () {
      var val = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        val[_i] = arguments[_i];
      }

      return setState(unshift(val));
    },
    insertAt: function (val, index) {
      return setState(insertAt(val, index));
    },
    upsertAt: function (val, index) {
      return setState(upsertAt(val, index));
    },
    deleteAt: function (index) {
      return setState(deleteAt(index));
    }
  };
};
var useArrayState = function (initialState) {
  return useObjectState(arrayStateFactory, initialState);
};

var booleanStateFactory = function (setState) {
  return {
    setTrue: function () {
      return setState(true);
    },
    setFalse: function () {
      return setState(false);
    },
    toggle: function () {
      return setState(function (state) {
        return !state;
      });
    }
  };
};
var useBooleanState = function (initialState) {
  return useObjectState(booleanStateFactory, initialState);
};

var incrementBy = function (val) {
  return function (state) {
    var max = state.max,
        _a = state.count,
        count = _a === void 0 ? 0 : _a;

    if (max !== undefined && count + val > max) {
      return __assign(__assign({}, state), {
        count: max
      });
    } else {
      return __assign(__assign({}, state), {
        count: count + val
      });
    }
  };
};
var decrementBy = function (val) {
  return function (state) {
    var min = state.min,
        _a = state.count,
        count = _a === void 0 ? 0 : _a;

    if (min !== undefined && count - val <= min) {
      return __assign(__assign({}, state), {
        count: min
      });
    } else {
      return __assign(__assign({}, state), {
        count: count - val
      });
    }
  };
};
var setCount = function (count) {
  return function (state) {
    return __assign(__assign({}, state), {
      count: count
    });
  };
};
var setMin = function (min) {
  return function (state) {
    return __assign(__assign({}, state), {
      min: min
    });
  };
};
var setMax = function (max) {
  return function (state) {
    return __assign(__assign({}, state), {
      max: max
    });
  };
};

var counterStateFactory = function (setState) {
  return {
    increment: function () {
      return setState(incrementBy(1));
    },
    decrement: function () {
      return setState(decrementBy(1));
    },
    incrementBy: function (val) {
      return setState(incrementBy(val));
    },
    decrementBy: function (val) {
      return setState(decrementBy(val));
    },
    setCount: function (count) {
      return setState(setCount(count));
    },
    setMin: function (min) {
      return setState(setMin(min));
    },
    setMax: function (max) {
      return setState(setMax(max));
    }
  };
};
var useCounterState = function (initialState) {
  if (initialState === void 0) {
    initialState = {
      count: 0
    };
  }

  var _a = useObjectState(counterStateFactory, initialState),
      _b = _a.state,
      count = _b.count,
      min = _b.min,
      max = _b.max,
      setState = _a.setState,
      counterState = __rest(_a, ["state", "setState"]);

  return __assign({
    count: count,
    min: min,
    max: max
  }, counterState);
};

var mapStateFactory = function (setState) {
  return {
    clear: function () {
      return setState(new Map());
    },
    set: function (key, value) {
      return setState(function (state) {
        return new Map(state.set(key, value));
      });
    },
    delete: function (key) {
      return setState(function (state) {
        state.delete(key);
        return new Map(state);
      });
    }
  };
};
var useMapState = function (initialEntries) {
  return useObjectState(mapStateFactory, new Map(initialEntries));
};

var findIndex = function (arr, value) {
  return arr.findIndex(function (element) {
    return JSON.stringify(element) === JSON.stringify(value);
  });
};

var toggle = function (values) {
  return function (state) {
    var stateCopy = state.slice();
    values.forEach(function (value) {
      var index = findIndex(stateCopy, value);

      if (index >= 0) {
        stateCopy.splice(index, 1);
      } else {
        stateCopy.push(value);
      }
    });
    return stateCopy;
  };
};
var push$1 = function (values) {
  return function (state) {
    var uniqueNewVals = [];
    values.forEach(function (value) {
      if (findIndex(state, value) < 0) {
        uniqueNewVals.push(value);
      }
    });
    return push(uniqueNewVals)(state);
  };
};
var unshift$1 = function (values) {
  return function (state) {
    var uniqueNewVals = [];
    values.forEach(function (value) {
      if (findIndex(state, value) < 0) {
        uniqueNewVals.push(value);
      }
    });
    return unshift(uniqueNewVals)(state);
  };
};
var upsertAt$1 = function (val, index) {
  return function (state) {
    var indexOfVal = findIndex(state, val);

    if (indexOfVal < 0) {
      return upsertAt(val, index)(state);
    }

    return state;
  };
};
var insertAt$1 = function (val, index) {
  return function (state) {
    var indexOfVal = findIndex(state, val);

    if (indexOfVal < 0) {
      return insertAt(val, index)(state);
    }

    return state;
  };
};

var uniqueArrayStateFactory = function (setState) {
  return __assign(__assign({}, arrayStateFactory(setState)), {
    push: function () {
      var val = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        val[_i] = arguments[_i];
      }

      return setState(push$1(val));
    },
    toggle: function () {
      var val = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        val[_i] = arguments[_i];
      }

      return setState(toggle(val));
    },
    unshift: function () {
      var val = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        val[_i] = arguments[_i];
      }

      return setState(unshift$1(val));
    },
    insertAt: function (val, index) {
      return setState(insertAt$1(val, index));
    },
    upsertAt: function (val, index) {
      return setState(upsertAt$1(val, index));
    }
  });
};
var useUniqueArrayState = function (initialState) {
  return useObjectState(uniqueArrayStateFactory, initialState);
};

export { anchorElStateFactory, arrayStateFactory, booleanStateFactory, counterStateFactory, mapStateFactory, uniqueArrayStateFactory, useAnchorElState, useArrayState, useBooleanState, useCounterState, useMapState, useObjectState, useUniqueArrayState };
//# sourceMappingURL=index.es.js.map