3d-spinner 0.9.0 → 0.9.2

package/dist/cjs/engines/little-3d-engine/loaders/obj.cjs

@@ -0,0 +1,58 @@
+"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/engines/little-3d-engine/loaders/obj.ts
+var obj_exports = {};
+__export(obj_exports, {
+  parseObj: () => parseObj
+});
+module.exports = __toCommonJS(obj_exports);
+var DEFAULT_COLORS = ["#3b82f6", "#8b5cf6", "#ec4899", "#f59e0b", "#10b981", "#ef4444"];
+function resolveIndex(token, vertexCount) {
+  const n = parseInt(token, 10);
+  return n < 0 ? vertexCount + n : n - 1;
+}
+function parseObj(text, options = {}) {
+  const colors = options.colors ?? DEFAULT_COLORS;
+  const vertices = [];
+  const faces = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const parts = trimmed.split(/\s+/);
+    const keyword = parts[0];
+    if (keyword === "v") {
+      vertices.push({
+        x: parseFloat(parts[1]),
+        y: parseFloat(parts[2]),
+        z: parseFloat(parts[3])
+      });
+    } else if (keyword === "f") {
+      const indices = [];
+      for (let i = 1; i < parts.length; i++) {
+        const vertexToken = parts[i].split("/")[0];
+        indices.push(resolveIndex(vertexToken, vertices.length));
+      }
+      if (indices.length >= 3) {
+        faces.push({ indices, color: colors[faces.length % colors.length] });
+      }
+    }
+  }
+  return { vertices, faces };
+}

package/dist/cjs/engines/little-tween-engine/little-tween-engine.cjs

@@ -0,0 +1,279 @@
+"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/engines/little-tween-engine/little-tween-engine.ts
+var little_tween_engine_exports = {};
+__export(little_tween_engine_exports, {
+  LittleTweenEngine: () => LittleTweenEngine,
+  cubic: () => cubic,
+  ease: () => ease,
+  easeInBack: () => easeInBack,
+  easeInBounce: () => easeInBounce,
+  easeInCirc: () => easeInCirc,
+  easeInCubic: () => easeInCubic,
+  easeInElastic: () => easeInElastic,
+  easeInExpo: () => easeInExpo,
+  easeInOutBack: () => easeInOutBack,
+  easeInOutBounce: () => easeInOutBounce,
+  easeInOutCirc: () => easeInOutCirc,
+  easeInOutCubic: () => easeInOutCubic,
+  easeInOutElastic: () => easeInOutElastic,
+  easeInOutExpo: () => easeInOutExpo,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutQuart: () => easeInOutQuart,
+  easeInOutQuint: () => easeInOutQuint,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInQuart: () => easeInQuart,
+  easeInQuint: () => easeInQuint,
+  easeInSine: () => easeInSine,
+  easeOutBack: () => easeOutBack,
+  easeOutBounce: () => easeOutBounce,
+  easeOutCirc: () => easeOutCirc,
+  easeOutCubic: () => easeOutCubic,
+  easeOutElastic: () => easeOutElastic,
+  easeOutExpo: () => easeOutExpo,
+  easeOutQuad: () => easeOutQuad,
+  easeOutQuart: () => easeOutQuart,
+  easeOutQuint: () => easeOutQuint,
+  easeOutSine: () => easeOutSine,
+  easeTypes: () => easeTypes,
+  linear: () => linear,
+  quadratic: () => quadratic,
+  quartic: () => quartic,
+  quintic: () => quintic
+});
+module.exports = __toCommonJS(little_tween_engine_exports);
+
+// src/engines/little-tween-engine/core/tweens.ts
+function input(value, overextend) {
+  if (Number.isNaN(value)) return 0;
+  if (overextend) return value;
+  return Math.min(1, Math.max(0, value));
+}
+function linear(value, overextend = false) {
+  return input(value, overextend);
+}
+function quadratic(value, overextend = false) {
+  return easeInQuad(value, overextend);
+}
+function cubic(value, overextend = false) {
+  return easeInCubic(value, overextend);
+}
+function quartic(value, overextend = false) {
+  return easeInQuart(value, overextend);
+}
+function quintic(value, overextend = false) {
+  return easeInQuint(value, overextend);
+}
+function easeInSine(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - Math.cos(x * Math.PI / 2);
+}
+function easeOutSine(value, overextend = false) {
+  const x = input(value, overextend);
+  return Math.sin(x * Math.PI / 2);
+}
+function easeInOutSine(value, overextend = false) {
+  const x = input(value, overextend);
+  return -(Math.cos(Math.PI * x) - 1) / 2;
+}
+function easeInQuad(value, overextend = false) {
+  const x = input(value, overextend);
+  return x * x;
+}
+function easeOutQuad(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - (1 - x) * (1 - x);
+}
+function easeInOutQuad(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;
+}
+function easeInCubic(value, overextend = false) {
+  const x = input(value, overextend);
+  return x * x * x;
+}
+function easeOutCubic(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - Math.pow(1 - x, 3);
+}
+function easeInOutCubic(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;
+}
+function easeInQuart(value, overextend = false) {
+  const x = input(value, overextend);
+  return x * x * x * x;
+}
+function easeOutQuart(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - Math.pow(1 - x, 4);
+}
+function easeInOutQuart(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;
+}
+function easeInQuint(value, overextend = false) {
+  const x = input(value, overextend);
+  return x * x * x * x * x;
+}
+function easeOutQuint(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - Math.pow(1 - x, 5);
+}
+function easeInOutQuint(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;
+}
+function easeInExpo(value, overextend = false) {
+  const x = input(value, overextend);
+  return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
+}
+function easeOutExpo(value, overextend = false) {
+  const x = input(value, overextend);
+  return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);
+}
+function easeInOutExpo(value, overextend = false) {
+  const x = input(value, overextend);
+  return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? Math.pow(2, 20 * x - 10) / 2 : (2 - Math.pow(2, -20 * x + 10)) / 2;
+}
+function easeInCirc(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - Math.sqrt(1 - Math.pow(x, 2));
+}
+function easeOutCirc(value, overextend = false) {
+  const x = input(value, overextend);
+  return Math.sqrt(1 - Math.pow(x - 1, 2));
+}
+function easeInOutCirc(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
+}
+function easeInBack(value, overextend = false) {
+  const x = input(value, overextend);
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return c3 * x * x * x - c1 * x * x;
+}
+function easeOutBack(value, overextend = false) {
+  const x = input(value, overextend);
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);
+}
+function easeInOutBack(value, overextend = false) {
+  const x = input(value, overextend);
+  const c1 = 1.70158;
+  const c2 = c1 * 1.525;
+  return x < 0.5 ? Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+}
+function easeInElastic(value, overextend = false) {
+  const x = input(value, overextend);
+  const c4 = 2 * Math.PI / 3;
+  return x === 0 ? 0 : x === 1 ? 1 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);
+}
+function easeOutElastic(value, overextend = false) {
+  const x = input(value, overextend);
+  const c4 = 2 * Math.PI / 3;
+  return x === 0 ? 0 : x === 1 ? 1 : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;
+}
+function easeInOutElastic(value, overextend = false) {
+  const x = input(value, overextend);
+  const c5 = 2 * Math.PI / 4.5;
+  return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2 : Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5) / 2 + 1;
+}
+function easeInBounce(value, overextend = false) {
+  const x = input(value, overextend);
+  return 1 - easeOutBounce(1 - x, true);
+}
+function easeOutBounce(value, overextend = false) {
+  let x = input(value, overextend);
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (x < 1 / d1) {
+    return n1 * x * x;
+  }
+  if (x < 2 / d1) {
+    x -= 1.5 / d1;
+    return n1 * x * x + 0.75;
+  }
+  if (x < 2.5 / d1) {
+    x -= 2.25 / d1;
+    return n1 * x * x + 0.9375;
+  }
+  x -= 2.625 / d1;
+  return n1 * x * x + 0.984375;
+}
+function easeInOutBounce(value, overextend = false) {
+  const x = input(value, overextend);
+  return x < 0.5 ? (1 - easeOutBounce(1 - 2 * x, true)) / 2 : (1 + easeOutBounce(2 * x - 1, true)) / 2;
+}
+var easeTypes = {
+  linear,
+  quadratic,
+  cubic,
+  quartic,
+  quintic,
+  easeInSine,
+  easeOutSine,
+  easeInOutSine,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easeInCubic,
+  easeOutCubic,
+  easeInOutCubic,
+  easeInQuart,
+  easeOutQuart,
+  easeInOutQuart,
+  easeInQuint,
+  easeOutQuint,
+  easeInOutQuint,
+  easeInExpo,
+  easeOutExpo,
+  easeInOutExpo,
+  easeInCirc,
+  easeOutCirc,
+  easeInOutCirc,
+  easeInBack,
+  easeOutBack,
+  easeInOutBack,
+  easeInElastic,
+  easeOutElastic,
+  easeInOutElastic,
+  easeInBounce,
+  easeOutBounce,
+  easeInOutBounce
+};
+function ease(type, value, overextend = false) {
+  return easeTypes[type](value, overextend);
+}
+
+// src/engines/little-tween-engine/little-tween-engine.ts
+var LittleTweenEngine = class {
+  constructor(options = {}) {
+    this.type = options.type ?? "linear";
+    this.overextend = options.overextend ?? false;
+  }
+  /** Map `value` through the selected ease type. */
+  value(value, type = this.type, overextend = this.overextend) {
+    return ease(type, value, overextend);
+  }
+};

package/dist/cjs/index.cjs

@@ -0,0 +1,120 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createSpinner: () => createSpinner
+});
+module.exports = __toCommonJS(index_exports);
+function clamp01(value) {
+  if (Number.isNaN(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function lerp(from, to, t) {
+  return from + (to - from) * t;
+}
+function createSpinner(target, options) {
+  if (!(target instanceof HTMLElement)) {
+    throw new Error("3d-spinner: createSpinner requires a target HTMLElement.");
+  }
+  const { animation } = options;
+  const indeterminate = options.type === "indeterminate";
+  if (indeterminate && options.periodMs !== void 0 && (!Number.isFinite(options.periodMs) || options.periodMs <= 0)) {
+    throw new RangeError("3d-spinner: periodMs must be a finite number greater than zero.");
+  }
+  animation.mount(target);
+  const start = performance.now();
+  let rafId = 0;
+  let stopped = false;
+  let destroyed = false;
+  let entered = false;
+  let exiting = false;
+  let current = 0;
+  let targetProgress = 0;
+  let deadline = Infinity;
+  if (!indeterminate) {
+    const opts = options;
+    if (typeof opts.progress === "number") {
+      current = clamp01(opts.progress);
+      targetProgress = current;
+    }
+    if (typeof opts.timeout === "number") deadline = Math.min(deadline, start + opts.timeout);
+    if (opts.until instanceof Date) deadline = Math.min(deadline, opts.until.getTime());
+  }
+  function computeProgress(now) {
+    if (!indeterminate) {
+      if (now >= deadline) targetProgress = 1;
+      current = lerp(current, targetProgress, 0.12);
+      if (Math.abs(targetProgress - current) < 5e-4) current = targetProgress;
+      return current;
+    }
+    const opts = options;
+    const period = opts.periodMs ?? 2e3;
+    const t = (now - start) / period;
+    if ((opts.loop ?? "bounce") === "restart") return t - Math.floor(t);
+    const phase = t - 2 * Math.floor(t / 2);
+    return phase <= 1 ? phase : 2 - phase;
+  }
+  function frame(now) {
+    if (stopped) return;
+    const progress = computeProgress(now);
+    if (!entered && (indeterminate || progress > 0)) {
+      animation.enter(now);
+      entered = true;
+    }
+    if (!exiting && entered && !indeterminate && progress >= 1 && targetProgress >= 1) {
+      animation.exit(now);
+      exiting = true;
+    }
+    const target2 = indeterminate ? progress : targetProgress;
+    animation.render(now, { progress, targetProgress: target2, indeterminate });
+    if (exiting && animation.isFinished()) {
+      halt();
+      return;
+    }
+    rafId = requestAnimationFrame(frame);
+  }
+  function halt() {
+    if (stopped) return;
+    stopped = true;
+    if (rafId) cancelAnimationFrame(rafId);
+    rafId = 0;
+  }
+  function setProgress(value) {
+    if (!indeterminate) targetProgress = clamp01(value);
+  }
+  function stop() {
+    if (stopped || exiting) return;
+    if (!entered) {
+      halt();
+      return;
+    }
+    animation.exit(performance.now());
+    exiting = true;
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    halt();
+    animation.destroy();
+  }
+  rafId = requestAnimationFrame(frame);
+  return { setProgress, stop, destroy };
+}

package/dist/cjs/motion/motion.cjs

@@ -0,0 +1,140 @@
+"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/motion/motion.ts
+var motion_exports = {};
+__export(motion_exports, {
+  circleMotion: () => circleMotion,
+  figureEightMotion: () => figureEightMotion,
+  squareMotion: () => squareMotion,
+  wanderMotion: () => wanderMotion
+});
+module.exports = __toCommonJS(motion_exports);
+
+// src/motion/circle.ts
+function circleMotion(options = {}) {
+  const radius = options.radius ?? 1.3;
+  const periodMs = options.periodMs ?? 3e3;
+  const tilt = options.tilt ?? 0.5;
+  const direction = options.direction ?? 1;
+  const cosTilt = Math.cos(tilt);
+  const sinTilt = Math.sin(tilt);
+  return {
+    positionAt(t) {
+      const angle = direction * t / periodMs * Math.PI * 2;
+      const x = radius * Math.cos(angle);
+      const flatY = radius * Math.sin(angle);
+      return { x, y: flatY * cosTilt, z: flatY * sinTilt };
+    }
+  };
+}
+
+// src/motion/square.ts
+function squareMotion(options = {}) {
+  const half = (options.size ?? 2.4) / 2;
+  const periodMs = options.periodMs ?? 4e3;
+  const tilt = options.tilt ?? 0.45;
+  const direction = options.direction ?? 1;
+  const cosTilt = Math.cos(tilt);
+  const sinTilt = Math.sin(tilt);
+  return {
+    positionAt(t) {
+      const lap = direction * t / periodMs;
+      const s = (lap - Math.floor(lap)) * 4;
+      const edge = Math.floor(s);
+      const f = s - edge;
+      let flatX;
+      let flatY;
+      if (edge === 0) {
+        flatX = -half + 2 * half * f;
+        flatY = -half;
+      } else if (edge === 1) {
+        flatX = half;
+        flatY = -half + 2 * half * f;
+      } else if (edge === 2) {
+        flatX = half - 2 * half * f;
+        flatY = half;
+      } else {
+        flatX = -half;
+        flatY = half - 2 * half * f;
+      }
+      return { x: flatX, y: flatY * cosTilt, z: flatY * sinTilt };
+    }
+  };
+}
+
+// src/motion/figure-eight.ts
+var LOOP_X = 1.5;
+var LOOP_Y = 1;
+var LOOP_Z = 1.05;
+function figureEightMotion(options = {}) {
+  const size = options.size ?? 1;
+  const periodMs = options.periodMs ?? 3600;
+  return {
+    positionAt(t) {
+      const a = t / periodMs * Math.PI * 2;
+      return {
+        x: size * LOOP_X * Math.sin(a),
+        y: size * LOOP_Y * Math.sin(a) * Math.cos(a),
+        z: size * LOOP_Z * Math.cos(a)
+      };
+    }
+  };
+}
+
+// src/motion/wander.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function axisDrift(rnd, omega, bound) {
+  const components = [0, 1, 2].map(() => ({
+    freq: 0.5 + rnd() * 1.4,
+    phase: rnd() * Math.PI * 2,
+    weight: 0.5 + rnd()
+  }));
+  const total = components.reduce((sum, c) => sum + c.weight, 0);
+  return (t) => {
+    let value = 0;
+    for (const c of components) value += c.weight * Math.sin(omega * c.freq * t + c.phase);
+    return value / total * bound;
+  };
+}
+function wanderMotion(options = {}) {
+  const boundX = options.bounds?.x ?? 1.4;
+  const boundY = options.bounds?.y ?? 1;
+  const boundZ = options.bounds?.z ?? 0.6;
+  const periodMs = options.periodMs ?? 9e3;
+  const seed = options.seed ?? Math.random() * 1e9 | 0;
+  const rnd = mulberry32(seed);
+  const omega = 2 * Math.PI / periodMs;
+  const driftX = axisDrift(rnd, omega, boundX);
+  const driftY = axisDrift(rnd, omega, boundY);
+  const driftZ = axisDrift(rnd, omega, boundZ);
+  return {
+    positionAt(t) {
+      return { x: driftX(t), y: driftY(t), z: driftZ(t) };
+    }
+  };
+}

package/dist/cjs/motion/transitions.cjs

@@ -0,0 +1,80 @@
+"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/motion/transitions.ts
+var transitions_exports = {};
+__export(transitions_exports, {
+  enterFromObjectDirection: () => enterFromObjectDirection,
+  grow: () => grow,
+  leaveInObjectDirection: () => leaveInObjectDirection,
+  shrink: () => shrink
+});
+module.exports = __toCommonJS(transitions_exports);
+var DEFAULT_DISTANCE = 3.5;
+function add(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function scaleVector(v, factor) {
+  return { x: v.x * factor, y: v.y * factor, z: v.z * factor };
+}
+function vectorLength(v) {
+  return Math.hypot(v.x, v.y, v.z);
+}
+function normalizeVector(v) {
+  const length = vectorLength(v);
+  if (length < 1e-6) return { x: 1, y: 0, z: 0 };
+  return scaleVector(v, 1 / length);
+}
+function resolveDirection(input, fallback) {
+  return normalizeVector(fallback ?? input.direction ?? input.velocity ?? { x: 1, y: 0, z: 0 });
+}
+function easeOutBack(delta) {
+  const c = 1.70158;
+  const u = delta - 1;
+  return 1 + (c + 1) * u * u * u + c * u * u;
+}
+function joinVelocity(input, options, durationMs) {
+  const inputSpeed = input.velocity ? vectorLength(input.velocity) : 0;
+  if (input.velocity && inputSpeed > 1e-6 && !options.direction) {
+    return input.velocity;
+  }
+  const distance = options.distance ?? DEFAULT_DISTANCE;
+  return scaleVector(resolveDirection(input, options.direction), distance / durationMs);
+}
+function enterFromObjectDirection(options = {}) {
+  return (input) => {
+    const durationMs = Math.max(1, input.durationMs);
+    const velocity = joinVelocity(input, options, durationMs);
+    const remaining = durationMs - input.elapsedMs;
+    return { position: add(input.position, scaleVector(velocity, -remaining)) };
+  };
+}
+function leaveInObjectDirection(options = {}) {
+  return (input) => {
+    const durationMs = Math.max(1, input.durationMs);
+    const velocity = joinVelocity(input, options, durationMs);
+    return { position: add(input.position, scaleVector(velocity, input.elapsedMs)) };
+  };
+}
+function grow() {
+  return (input) => ({ size: (input.size ?? 1) * easeOutBack(input.delta) });
+}
+function shrink() {
+  return (input) => ({ size: (input.size ?? 1) * (1 - input.delta * input.delta) });
+}

package/dist/engines/little-3d-engine/core/mesh.d.ts

@@ -11,6 +11,24 @@ export interface Mesh {
     vertices: Vec3[];
     faces: Face[];
 }
+/** Draw only outward-facing transparent surfaces. */
+export interface OneSidedTransparency {
+    mode: "one-sided";
+    /** Surface opacity from `0` (invisible) to `1` (opaque). Default `0.35`. */
+    opacity?: number;
+}
+/** Draw back surfaces before front surfaces to suggest a transparent solid. */
+export interface TwoSidedTransparency {
+    mode: "two-sided";
+    /** Front opacity shorthand; back opacity is derived as two-thirds of front. */
+    opacity?: number;
+    /** Back-surface opacity from `0` to `1`. Default `0.84`. */
+    backOpacity?: number;
+    /** Front-surface opacity from `0` to `1`. Default `0.56`. */
+    frontOpacity?: number;
+}
+/** Transparency mode for one mesh instance. */
+export type Transparency = OneSidedTransparency | TwoSidedTransparency;
 /** Position and orientation (Euler radians) applied to a mesh when rendered. */
 export interface Transform {
     position: Vec3;