@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/headless-test/runtime-primitives.mjs

@@ -0,0 +1,320 @@
+import { relative, resolve } from 'node:path';
+
+export function createHeadlessPrimitiveRuntime({ projectRoot = process.cwd() }) {
+  const createUnitColor = (r = 0, g = 0, b = 0, a = 1) => ({
+    r: Number(r),
+    g: Number(g),
+    b: Number(b),
+    a: Number(a),
+  });
+  const resolveHeadlessAssetPath = (sourcePath) => {
+    if (typeof sourcePath !== 'string') return null;
+    const trimmed = sourcePath.trim();
+    if (!trimmed) return null;
+    const assetRoot = resolve(projectRoot, 'assets');
+    const normalizedRelativePath = trimmed
+      .replace(/\\/g, '/')
+      .replace(/^\.?\//, '')
+      .replace(/^assets\//, '');
+    if (!normalizedRelativePath) return null;
+    const resolvedAssetPath = resolve(assetRoot, normalizedRelativePath);
+    const assetRelativePath = relative(assetRoot, resolvedAssetPath);
+    if (!assetRelativePath || assetRelativePath.startsWith('..')) {
+      return null;
+    }
+    return resolvedAssetPath;
+  };
+  const measureHeadlessText = (text, sizeOrOptions) => {
+    const textValue = String(text ?? '');
+    const optionSize = typeof sizeOrOptions === 'number'
+      ? sizeOrOptions
+      : sizeOrOptions && typeof sizeOrOptions === 'object'
+        ? Number(sizeOrOptions.size)
+        : NaN;
+    const size = Number.isFinite(optionSize) && optionSize > 0 ? optionSize : 16;
+    if (textValue.length === 0) {
+      return { width: 0, height: 0 };
+    }
+    return {
+      width: Number((textValue.length * size * 0.6).toFixed(3)),
+      height: size,
+    };
+  };
+
+  const makeVec2 = (x = 0, y = 0) => ({ x: Number(x), y: Number(y) });
+  const vec2 = function vec2(x = 0, y = 0) {
+    return makeVec2(x, y);
+  };
+  vec2.create = makeVec2;
+  vec2.add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+  vec2.sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+  vec2.scale = (v, scalar) => ({ x: v.x * scalar, y: v.y * scalar });
+  vec2.normalize = (v) => {
+    const magnitude = Math.hypot(v.x, v.y);
+    if (magnitude === 0) return { x: 0, y: 0 };
+    return { x: v.x / magnitude, y: v.y / magnitude };
+  };
+  vec2.dot = (a, b) => a.x * b.x + a.y * b.y;
+  vec2.distance = (a, b) => Math.hypot(b.x - a.x, b.y - a.y);
+  vec2.lerp = (a, b, t) => ({
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+  });
+  Object.defineProperty(vec2, 'length', {
+    value: (v) => Math.hypot(v.x, v.y),
+    writable: true,
+    configurable: true,
+  });
+  vec2.len = (v) => vec2.length(v);
+
+  const makeVec3 = (x = 0, y = 0, z = 0) => ({ x: Number(x), y: Number(y), z: Number(z) });
+  const vec3 = function vec3(x = 0, y = 0, z = 0) {
+    return makeVec3(x, y, z);
+  };
+  vec3.create = makeVec3;
+  vec3.add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y, z: a.z + b.z });
+  vec3.sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z });
+  vec3.scale = (v, scalar) => ({ x: v.x * scalar, y: v.y * scalar, z: v.z * scalar });
+  vec3.dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+  vec3.cross = (a, b) => ({
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x,
+  });
+  vec3.normalize = (v) => {
+    const magnitude = Math.hypot(v.x, v.y, v.z);
+    if (magnitude === 0) return { x: 0, y: 0, z: 0 };
+    return { x: v.x / magnitude, y: v.y / magnitude, z: v.z / magnitude };
+  };
+  vec3.distance = (a, b) => Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+  vec3.lerp = (a, b, t) => ({
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t,
+  });
+  Object.defineProperty(vec3, 'length', {
+    value: (v) => Math.hypot(v.x, v.y, v.z),
+    writable: true,
+    configurable: true,
+  });
+
+  const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+  const parseRect = (value) => (
+    value
+    && isFiniteNumber(value.x)
+    && isFiniteNumber(value.y)
+    && isFiniteNumber(value.w)
+    && isFiniteNumber(value.h)
+    ? value
+    : null
+  );
+  const parseRectFromComponents = (x, y, w, h) => (
+    isFiniteNumber(x)
+    && isFiniteNumber(y)
+    && isFiniteNumber(w)
+    && isFiniteNumber(h)
+    ? { x, y, w, h }
+    : null
+  );
+  const parsePoint = (value) => (
+    value
+    && isFiniteNumber(value.x)
+    && isFiniteNumber(value.y)
+    ? value
+    : null
+  );
+  const parseCircle = (value) => (
+    value
+    && isFiniteNumber(value.x)
+    && isFiniteNumber(value.y)
+    && isFiniteNumber(value.radius)
+    ? value
+    : null
+  );
+
+  const collisionRectRect = (a, b) => a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+  const collisionRectPoint = (rect, point) => (
+    point.x >= rect.x
+    && point.x <= rect.x + rect.w
+    && point.y >= rect.y
+    && point.y <= rect.y + rect.h
+  );
+  const collisionCircleCircle = (a, b) => Math.hypot(b.x - a.x, b.y - a.y) <= a.radius + b.radius;
+  const collisionCirclePoint = (circle, point) => Math.hypot(point.x - circle.x, point.y - circle.y) <= circle.radius;
+  const collisionCircleRect = (circle, rect) => {
+    const nearestX = Math.max(rect.x, Math.min(circle.x, rect.x + rect.w));
+    const nearestY = Math.max(rect.y, Math.min(circle.y, rect.y + rect.h));
+    return Math.hypot(circle.x - nearestX, circle.y - nearestY) <= circle.radius;
+  };
+
+  const collision = {
+    rectRect: (...args) => {
+      let lhs = null;
+      let rhs = null;
+      if (args.length >= 2 && typeof args[0] === 'object' && typeof args[1] === 'object') {
+        lhs = parseRect(args[0]);
+        rhs = parseRect(args[1]);
+      } else if (args.length >= 8) {
+        lhs = parseRectFromComponents(args[0], args[1], args[2], args[3]);
+        rhs = parseRectFromComponents(args[4], args[5], args[6], args[7]);
+      }
+      return !!lhs && !!rhs && collisionRectRect(lhs, rhs);
+    },
+    rectPoint: (rect, point) => {
+      const parsedRect = parseRect(rect);
+      const parsedPoint = parsePoint(point);
+      return !!parsedRect && !!parsedPoint && collisionRectPoint(parsedRect, parsedPoint);
+    },
+    circleCircle: (a, b) => {
+      const lhs = parseCircle(a);
+      const rhs = parseCircle(b);
+      return !!lhs && !!rhs && collisionCircleCircle(lhs, rhs);
+    },
+    circlePoint: (circle, point) => {
+      const parsedCircle = parseCircle(circle);
+      const parsedPoint = parsePoint(point);
+      return !!parsedCircle && !!parsedPoint && collisionCirclePoint(parsedCircle, parsedPoint);
+    },
+    circleRect: (circle, rect) => {
+      const parsedCircle = parseCircle(circle);
+      const parsedRect = parseRect(rect);
+      return !!parsedCircle && !!parsedRect && collisionCircleRect(parsedCircle, parsedRect);
+    },
+    rectRectBatch: (rect, rects) => {
+      const parsedRect = parseRect(rect);
+      if (!parsedRect || !Array.isArray(rects)) return [];
+      return rects.map((candidate) => {
+        const parsedCandidate = parseRect(candidate);
+        return !!parsedCandidate && collisionRectRect(parsedRect, parsedCandidate);
+      });
+    },
+    rectPointBatch: (rect, points) => {
+      const parsedRect = parseRect(rect);
+      if (!parsedRect || !Array.isArray(points)) return [];
+      return points.map((candidate) => {
+        const parsedCandidate = parsePoint(candidate);
+        return !!parsedCandidate && collisionRectPoint(parsedRect, parsedCandidate);
+      });
+    },
+    circleCircleBatch: (circle, circles) => {
+      const parsedCircle = parseCircle(circle);
+      if (!parsedCircle || !Array.isArray(circles)) return [];
+      return circles.map((candidate) => {
+        const parsedCandidate = parseCircle(candidate);
+        return !!parsedCandidate && collisionCircleCircle(parsedCircle, parsedCandidate);
+      });
+    },
+    circlePointBatch: (circle, points) => {
+      const parsedCircle = parseCircle(circle);
+      if (!parsedCircle || !Array.isArray(points)) return [];
+      return points.map((candidate) => {
+        const parsedCandidate = parsePoint(candidate);
+        return !!parsedCandidate && collisionCirclePoint(parsedCircle, parsedCandidate);
+      });
+    },
+    circleRectBatch: (circle, rects) => {
+      const parsedCircle = parseCircle(circle);
+      if (!parsedCircle || !Array.isArray(rects)) return [];
+      return rects.map((candidate) => {
+        const parsedCandidate = parseRect(candidate);
+        return !!parsedCandidate && collisionCircleRect(parsedCircle, parsedCandidate);
+      });
+    },
+  };
+
+  const collide = {
+    rects: (x1, y1, w1, h1, x2, y2, w2, h2) => collision.rectRect(
+      { x: x1, y: y1, w: w1, h: h1 },
+      { x: x2, y: y2, w: w2, h: h2 },
+    ),
+    circles: (x1, y1, r1, x2, y2, r2) => collision.circleCircle(
+      { x: x1, y: y1, radius: r1 },
+      { x: x2, y: y2, radius: r2 },
+    ),
+    pointRect: (px, py, rx, ry, rw, rh) => collision.rectPoint(
+      { x: rx, y: ry, w: rw, h: rh },
+      { x: px, y: py },
+    ),
+    pointCircle: (px, py, cx, cy, cr) => collision.circlePoint(
+      { x: cx, y: cy, radius: cr },
+      { x: px, y: py },
+    ),
+    rectCircle: (rx, ry, rw, rh, cx, cy, cr) => collision.circleRect(
+      { x: cx, y: cy, radius: cr },
+      { x: rx, y: ry, w: rw, h: rh },
+    ),
+  };
+
+  const math = {
+    lerp: (a, b, t) => a + (b - a) * t,
+    clamp: (value, min, max) => Math.max(min, Math.min(max, value)),
+    random: (...args) => {
+      if (args.length === 0) {
+        return Math.random();
+      }
+      if (args.length === 1) {
+        return Math.random() * args[0];
+      }
+      return args[0] + Math.random() * (args[1] - args[0]);
+    },
+    randomInt: (min, max) => Math.floor(min + Math.random() * (max - min + 1)),
+    randomFloat: (min, max) => min + Math.random() * (max - min),
+    distance: (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1),
+    angle: (x1, y1, x2, y2) => Math.atan2(y2 - y1, x2 - x1),
+    degToRad: (degrees) => (degrees * Math.PI) / 180,
+    radToDeg: (radians) => (radians * 180) / Math.PI,
+    PI: Math.PI,
+    TAU: Math.PI * 2,
+  };
+
+  const timer = {
+    after: (_seconds, callback) => {
+      const id = Symbol('after');
+      if (typeof callback === 'function') callback();
+      return id;
+    },
+    every: (_seconds, callback) => {
+      const id = Symbol('every');
+      if (typeof callback === 'function') callback();
+      return id;
+    },
+    cancel: () => {},
+    getDelta: () => 1 / 60,
+    getTime: () => 0,
+  };
+
+  const color = (...args) => ({ kind: 'color', args });
+  const rgb = (r = 0, g = 0, b = 0) => createUnitColor(r, g, b, 1);
+  const rgba = (r = 0, g = 0, b = 0, a = 1) => createUnitColor(r, g, b, a);
+  const Color = {
+    WHITE: createUnitColor(1, 1, 1, 1),
+    BLACK: createUnitColor(0, 0, 0, 1),
+    RED: createUnitColor(1, 0, 0, 1),
+    YELLOW: createUnitColor(1, 1, 0, 1),
+    TRANSPARENT: createUnitColor(0, 0, 0, 0),
+  };
+  const colors = {
+    white: { r: 255, g: 255, b: 255, a: 255 },
+    black: { r: 0, g: 0, b: 0, a: 255 },
+    red: { r: 255, g: 0, b: 0, a: 255 },
+    yellow: { r: 255, g: 255, b: 0, a: 255 },
+    transparent: { r: 0, g: 0, b: 0, a: 0 },
+  };
+
+  return {
+    createUnitColor,
+    resolveHeadlessAssetPath,
+    measureHeadlessText,
+    vec2,
+    vec3,
+    collision,
+    collide,
+    math,
+    timer,
+    color,
+    rgb,
+    rgba,
+    Color,
+    colors,
+  };
+}