@rickosborne/rebound/number-range.cjs

Rick Osborne's utilities for working with bounded numbers

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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 number_range_exports = {};
__export(number_range_exports, {
  NumberRange: () => NumberRange
});
module.exports = __toCommonJS(number_range_exports);
var import_foundation = require("@rickosborne/foundation");
var import_range_base = require("./range-base.cjs");
var import_range_like = require("./range-like.cjs");
var import_range = require("./range.cjs");
const _NumberRange = class _NumberRange extends import_range_base.RangeBase {
  constructor(isLowerInc, lower, isInt, upper, isUpperInc) {
    if (!Number.isFinite(lower) && !isLowerInc || !Number.isFinite(upper) && !isUpperInc) {
      throw new RangeError(`Unbounded (infinite) upper/lower must be inclusive`);
    }
    let isSingleton = false;
    let isEmpty = false;
    if (lower > upper) {
      throw new RangeError("Expected lower <= upper");
    }
    if (lower === upper) {
      if (!isLowerInc && !isUpperInc) {
        throw new Error("Expected at least one inclusive when lower === upper");
      }
      isSingleton = isLowerInc && isUpperInc;
      isEmpty = !isSingleton;
    }
    super(
      isLowerInc,
      Number.isFinite(lower) ? lower : import_range_like.unbounded,
      Number.isFinite(upper) ? upper : import_range_like.unbounded,
      isUpperInc,
      import_foundation.numberAsc
    );
    this.lower = lower;
    this.isInt = isInt;
    this.upper = upper;
    this.isSingleton = isSingleton;
    this.isEmpty = isEmpty;
    this.label = (0, import_range.rangeFromChecked)({ isInt, isLowerInc, isUpperInc, lower, upper });
  }
  isEmpty;
  isSingleton;
  label;
  assertCanScaleFrom(other) {
    if (!this.isBounded || !other.isBounded) {
      throw new RangeError("Cannot scale with unbounded range");
    }
    if (other.lower >= other.upper) {
      throw new RangeError("Not enough source range");
    }
  }
  compareTo(other) {
    const compared = super.compareTo(other);
    if (compared !== 0) {
      return compared;
    }
    if (other instanceof _NumberRange) {
      if (this.isInt && !other.isInt) {
        return -1;
      } else if (!this.isInt && other.isInt) {
        return 1;
      }
    }
    return 0;
  }
  encloses(other) {
    if (other instanceof _NumberRange && this.step > other.step) {
      return false;
    }
    return super.encloses(other);
  }
  isType(obj) {
    return typeof obj === "number" && !Number.isNaN(obj);
  }
};
__name(_NumberRange, "NumberRange");
let NumberRange = _NumberRange;
//# sourceMappingURL=number-range.cjs.map