@litecanvas/utils/dist/math.js

Utilities to help build litecanvas games

(() => {
  var __defProp = Object.defineProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // src/_global.js
  globalThis.utils = globalThis.utils || {};
  globalThis.utils.global = (overrides = true) => {
    for (const key in globalThis.utils) {
      if ("global" === key) continue;
      if (overrides || globalThis[key] === void 0) {
        globalThis[key] = globalThis.utils[key];
      }
    }
  };

  // src/math/index.js
  var index_exports = {};
  __export(index_exports, {
    advance: () => advance_default,
    almost: () => almost_default,
    clamp: () => clamp_default,
    diff: () => diff_default,
    dist: () => dist_default,
    fract: () => fract_default,
    lerpAngle: () => lerp_angle_default,
    mag: () => mag_default,
    mean: () => mean_default,
    median: () => median_default,
    mod: () => mod_default,
    move: () => move_default,
    percent: () => percent_default,
    smoothstep: () => smoothstep_default,
    sum: () => sum_default,
    wave: () => wave_default
  });

  // src/debug/assert.js
  var assert_default = (condition, message = "Assertion failed") => {
    if (!condition) throw new Error(message);
  };

  // src/math/diff.js
  var diff_default = (a, b) => {
    DEV: assert_default(
      Number.isFinite(a),
      "[litecanvas/utils] diff() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(b),
      "[litecanvas/utils] diff() 2nd param must be a number"
    );
    return Math.abs(b - a);
  };

  // src/math/fract.js
  var fract_default = (value) => {
    DEV: assert_default(
      Number.isFinite(value),
      "[litecanvas/utils] fract() 1st param must be a number"
    );
    return value % 1;
  };

  // src/debug/is.js
  var is_default = (value, type) => {
    if (typeof type === "function") {
      return value instanceof type;
    } else if (type === "array") {
      return Array.isArray(value);
    } else if (type === "number") {
      return "number" === typeof value && !Number.isNaN(value);
    } else if (type === "infinity") {
      return "number" === typeof value && Infinity === Math.abs(value);
    }
    return typeof value === type;
  };

  // src/math/clamp.js
  var clamp_default = (value, min, max) => {
    DEV: assert_default(
      Number.isFinite(value),
      "[litecanvas/utils] clamp() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(min),
      "[litecanvas/utils] clamp() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(max),
      "[litecanvas/utils] clamp() 3rd param must be a number"
    );
    DEV: assert_default(
      max >= min,
      "[litecanvas/utils] clamp() the 2nd param must be less than the 3rd param"
    );
    if (value < min) return min;
    if (value > max) return max;
    return value;
  };

  // src/vector/index.js
  var PI2 = 2 * Math.PI;
  var float = parseFloat;
  var V = class {
    /**
     * @param {number} [x=0]
     * @param {number} [y]
     */
    constructor(x = 0, y = x) {
      this.x = float(x) || 0;
      this.y = float(y) || 0;
    }
    /**
     * @returns {string}
     */
    toString() {
      return `Vector (${this.x}, ${this.y})`;
    }
  };
  var Vector = V;

  // src/math/advance.js
  var advance_default = (position, velocity, acceleration, deltaTime = 1) => {
    DEV: assert_default(
      is_default(position, Vector),
      "[litecanvas/utils] advance() 1st param must be a Vector"
    );
    DEV: assert_default(
      is_default(velocity, Vector),
      "[litecanvas/utils] advance() 2nd param must be a Vector"
    );
    DEV: assert_default(
      null == acceleration || is_default(acceleration, Vector),
      "[litecanvas/utils] advance() 3rd param must be a Vector or null"
    );
    DEV: assert_default(
      Number.isFinite(deltaTime),
      "[litecanvas/utils] advance() 4th param must be a number"
    );
    if (acceleration) {
      velocity.x += acceleration.x * deltaTime;
      velocity.y += acceleration.y * deltaTime;
    }
    position.x += velocity.x * deltaTime;
    position.y += velocity.y * deltaTime;
  };

  // src/math/mod.js
  var mod_default = (a, b) => {
    DEV: assert_default(
      Number.isFinite(a),
      "[litecanvas/utils] mod() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(b),
      "[litecanvas/utils] mod() 2nd param must be a number"
    );
    return (b + a % b) % b;
  };

  // src/math/dist.js
  var dist_default = (x1, y1, x2, y2) => {
    DEV: assert_default(
      Number.isFinite(x1),
      "[litecanvas/utils] dist() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(y1),
      "[litecanvas/utils] dist() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(x2),
      "[litecanvas/utils] dist() 3rd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(y2),
      "[litecanvas/utils] dist() 4th param must be a number"
    );
    return Math.hypot(x2 - x1, y2 - y1) || 0;
  };

  // src/math/mag.js
  var mag_default = (x, y) => {
    DEV: assert_default(
      Number.isFinite(x),
      "[litecanvas/utils] mag() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(y),
      "[litecanvas/utils] mag() 2nd param must be a number"
    );
    return Math.hypot(x, y);
  };

  // src/math/sum.js
  var sum_default = (values) => {
    DEV: assert_default(
      Array.isArray(values),
      "[litecanvas/utils] sum() 1st param must be an array"
    );
    let result = 0;
    for (let i = 0; i < values.length; i++) {
      result += values[i];
    }
    return result;
  };

  // src/math/mean.js
  var mean_default = (values) => {
    DEV: assert_default(
      Array.isArray(values),
      "[litecanvas/utils] mean() 1st param must be an array"
    );
    DEV: assert_default(
      values.length > 1,
      "[litecanvas/utils] mean() 1st param must be an array with at least 2 numbers"
    );
    return sum_default(values) / values.length;
  };

  // src/math/median.js
  var median_default = (values) => {
    DEV: assert_default(
      Array.isArray(values),
      "[litecanvas/utils] median() 1st param must be an array"
    );
    const sorted = values.sort((a, b) => a - b);
    const middle = Math.floor(sorted.length / 2);
    if (sorted.length % 2 === 0) {
      return (sorted[middle - 1] + sorted[middle]) / 2;
    }
    return sorted[middle];
  };

  // src/math/lerp-angle.js
  var lerp_angle_default = (start, end, amount) => {
    DEV: assert_default(
      Number.isFinite(start),
      "[litecanvas/utils] lerpAngle() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(end),
      "[litecanvas/utils] lerpAngle() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(amount),
      "[litecanvas/utils] lerpAngle() 3rd param must be a number"
    );
    let dif = (end - start) % 360;
    if (dif > 180) {
      dif -= 360;
    } else if (dif < -180) {
      dif += 360;
    }
    return start + dif * amount;
  };

  // src/math/percent.js
  var percent_default = (value, min, max) => {
    DEV: assert_default(
      Number.isFinite(value),
      "[litecanvas/utils] percent() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(min),
      "[litecanvas/utils] percent() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(max),
      "[litecanvas/utils] percent() 3rd param must be a number"
    );
    DEV: assert_default(
      max > min,
      "[litecanvas/utils] percent() 3rd param must be greater than 2nd param"
    );
    return clamp_default((value - min) / (max - min), 0, 1);
  };

  // src/math/wave.js
  var wave_default = (from, to, t, fn = Math.sin) => {
    DEV: assert_default(
      is_default(from, "number"),
      "[litecanvas] wave() 1st param must be a number"
    );
    DEV: assert_default(
      is_default(to, "number"),
      "[litecanvas] wave() 2nd param must be a number"
    );
    DEV: assert_default(is_default(t, "number"), "[litecanvas] wave() 3rd param must be a number");
    DEV: assert_default(
      is_default(fn, "function"),
      "[litecanvas] wave() 4rd param must be a function similar to (n: number) => number"
    );
    return from + (fn(t) + 1) / 2 * (to - from);
  };

  // src/math/move.js
  var move_default = (from, to, step) => {
    DEV: assert_default(
      Number.isFinite(from),
      "[litecanvas/utils] move() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(to),
      "[litecanvas/utils] move() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(step),
      "[litecanvas/utils] move() 3rd param must be a number"
    );
    return Math.abs(to - from) <= step ? to : from + Math.sign(to - from) * step;
  };

  // src/math/almost.js
  var almost_default = (a, b, epsilon = 1e-5) => diff_default(a, b) <= epsilon;

  // src/math/smoothstep.js
  var smoothstep_default = (min, max, value) => {
    DEV: assert_default(
      Number.isFinite(min),
      "[litecanvas/utils] smoothstep() 1st param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(max),
      "[litecanvas/utils] smoothstep() 2nd param must be a number"
    );
    DEV: assert_default(
      Number.isFinite(value),
      "[litecanvas/utils] smoothstep() 3rd param must be a number"
    );
    DEV: assert_default(
      max > min,
      "[litecanvas/utils] smoothstep() 2nd param must be greater than 1st param"
    );
    const t = clamp_default((value - min) / (max - min), 0, 1);
    return t * t * (3 - 2 * t);
  };

  // src/math/_web.js
  globalThis.utils = Object.assign(globalThis.utils || {}, index_exports);
})();