@techmely/utils/vector.js

Collection of helpful JavaScript / TypeScript utils

/*!
 * @techmely/utils
 * Copyright(c) 2021-2024 Techmely <techmely.creation@gmail.com>
 * MIT Licensed
 */

"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/vector.ts
var vector_exports = {};
__export(vector_exports, {
  add: () => add,
  clockwise: () => clockwise,
  dist: () => dist,
  dist2: () => dist2,
  div: () => div,
  dpr: () => dpr,
  getStrokeRadius: () => getStrokeRadius,
  isEqual: () => isEqual,
  isLeft: () => isLeft,
  len: () => len,
  len2: () => len2,
  lrp: () => lrp,
  med: () => med,
  mul: () => mul,
  neg: () => neg,
  per: () => per,
  rotAround: () => rotAround,
  sub: () => sub,
  toPointsArray: () => toPointsArray,
  uni: () => uni,
  vec: () => vec
});
module.exports = __toCommonJS(vector_exports);

// src/calculate.ts
function clamp(n, min, max) {
  return Math.min(max, Math.max(min, n));
}
function lerp(y1, y2, mu) {
  return y1 * (1 - mu) + y2 * mu;
}

// src/convert.ts
function toBoolean(val) {
  return val ? val !== "false" : false;
}

// src/env.ts
var import_meta = {};
var _envShim = /* @__PURE__ */ Object.create(null);
var _getEnv = (useShim) => globalThis.process?.env || // Node.js/Bun
import_meta.env || // Vite env
globalThis.Deno?.env.toObject() || // Deno env
globalThis.__env__ || // Custom env
(useShim ? _envShim : globalThis);
var envs = new Proxy(_envShim, {
  get(_, prop) {
    const env = _getEnv();
    return env[prop] ?? _envShim[prop];
  },
  has(_, prop) {
    const env = _getEnv();
    return prop in env || prop in _envShim;
  },
  set(_, prop, value) {
    const env = _getEnv(true);
    env[prop] = value;
    return true;
  },
  deleteProperty(_, prop) {
    if (!prop) {
      return false;
    }
    const env = _getEnv(true);
    delete env[prop];
    return true;
  },
  ownKeys() {
    const env = _getEnv();
    return Object.keys(env);
  }
});
var nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";

// src/process.ts
var _process = globalThis.process || /* @__PURE__ */ Object.create(null);
var processShims = {
  versions: {}
};
var process2 = new Proxy(_process, {
  get(target, prop) {
    if (prop === "env") {
      return envs;
    }
    if (prop in target) {
      return target[prop];
    }
    if (prop in processShims) {
      return processShims[prop];
    }
  }
});
var platform = _process.platform || "";

// src/is.ts
function isArray(val) {
  return val && Array.isArray(val);
}
var isBrowser = typeof window !== "undefined";
var isAndroid = isBrowser ? /(android)/i.test(navigator.userAgent) : false;
var match = isBrowser ? window.matchMedia || window.msMatchMedia : void 0;
var isMobile = isBrowser ? match?.("(pointer:coarse)")?.matches : false;
var isCrawler = isBrowser && (!("onscroll" in window) || /(gle|ing|ro)bot|crawl|spider/i.test(navigator.userAgent));
var isCI = toBoolean(envs.CI);
var isNodeTest = nodeENV === "test" || toBoolean(envs.TEST);
var isWindows = /^win/i.test(platform);
var isLinux = /^linux/i.test(platform);
var isMacOS = /^darwin/i.test(platform);

// src/vector.ts
function neg(A) {
  return [-A[0], -A[1]];
}
function add(A, B) {
  return [A[0] + B[0], A[1] + B[1]];
}
function sub(A, B) {
  return [A[0] - B[0], A[1] - B[1]];
}
function vec(A, B) {
  return [B[0] - A[0], B[1] - A[1]];
}
function mul(A, n) {
  return [A[0] * n, A[1] * n];
}
function div(A, n) {
  return [A[0] / n, A[1] / n];
}
function per(A) {
  return [A[1], -A[0]];
}
function dpr(A, B) {
  return A[0] * B[0] + A[1] * B[1];
}
function len(A) {
  return Math.hypot(A[0], A[1]);
}
function len2(A) {
  return A[0] * A[0] + A[1] * A[1];
}
function dist2(A, B) {
  return len2(sub(A, B));
}
function uni(A) {
  return div(A, len(A));
}
function dist(A, B) {
  return Math.hypot(A[1] - B[1], A[0] - B[0]);
}
function med(A, B) {
  return mul(add(A, B), 0.5);
}
function rotAround(A, C, r) {
  const s = Math.sin(r);
  const c = Math.cos(r);
  const px = A[0] - C[0];
  const py = A[1] - C[1];
  const nx = px * c - py * s;
  const ny = px * s + py * c;
  return [nx + C[0], ny + C[1]];
}
function lrp(A, B, t) {
  return add(A, mul(vec(A, B), t));
}
function isLeft(p1, pc, p2) {
  return (pc[0] - p1[0]) * (p2[1] - p1[1]) - (p2[0] - p1[0]) * (pc[1] - p1[1]);
}
function clockwise(p1, pc, p2) {
  return isLeft(p1, pc, p2) > 0;
}
function isEqual(a, b) {
  return a[0] === b[0] && a[1] === b[1];
}
function toPointsArray(points) {
  if (isArray(points[0])) {
    return points.map(([x, y, pressure = 0.5]) => [x, y, pressure]);
  }
  return points.map(({ x, y, pressure = 0.5 }) => [x, y, pressure]);
}
function getStrokeRadius(size, thinning, easing, pressure = 0.5) {
  if (!thinning) {
    return size / 2;
  }
  const newPressure = clamp(easing(pressure), 0, 1);
  return (thinning < 0 ? lerp(size, size + size * clamp(thinning, -0.95, -0.05), newPressure) : lerp(size - size * clamp(thinning, 0.05, 0.95), size, newPressure)) / 2;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  add,
  clockwise,
  dist,
  dist2,
  div,
  dpr,
  getStrokeRadius,
  isEqual,
  isLeft,
  len,
  len2,
  lrp,
  med,
  mul,
  neg,
  per,
  rotAround,
  sub,
  toPointsArray,
  uni,
  vec
});