rendx-interpolate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present wei.liang (https://github.com/weiliang0121)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/main.cjs

@@ -0,0 +1,177 @@
+"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/main.ts
+var main_exports = {};
+__export(main_exports, {
+  decompose: () => decompose,
+  interpolateColor: () => interpolateColor,
+  interpolateColors: () => interpolateColors,
+  interpolateMat2d: () => interpolateMat2d,
+  interpolateRotate: () => interpolateRotate,
+  interpolateValue: () => interpolateValue,
+  interpolateVec2: () => interpolateVec2,
+  lerp: () => lerp,
+  normalize: () => normalize,
+  slerp: () => slerp
+});
+module.exports = __toCommonJS(main_exports);
+
+// src/number.ts
+var lerp = (a, b) => {
+  const d = b - a;
+  return (t) => a + d * t;
+};
+var normalize = (a, b) => {
+  const d = b - a;
+  if (!d) return () => isNaN(d) ? NaN : 0.5;
+  const inv = 1 / d;
+  return (x) => (x - a) * inv;
+};
+
+// src/color.ts
+var HEX_REGEX = /^#([A-Fa-f0-9]{6})$/;
+var RGB_REGEX = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
+var parseColor = (color) => {
+  let match;
+  if (match = HEX_REGEX.exec(color)) {
+    const v = parseInt(match[1], 16);
+    return [v >> 16 & 255, v >> 8 & 255, v & 255];
+  }
+  if (match = RGB_REGEX.exec(color)) {
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+  }
+  throw new Error(`Unsupported color format: ${color}`);
+};
+var HEX_TABLE = new Array(256);
+for (let i = 0; i < 256; i++) HEX_TABLE[i] = i.toString(16).padStart(2, "0");
+var toHex = (n) => HEX_TABLE[n + 0.5 | 0];
+var interpolateColor = (c0, c1) => {
+  const [r0, g0, b0] = parseColor(c0);
+  const [r1, g1, b1] = parseColor(c1);
+  const dr = r1 - r0;
+  const dg = g1 - g0;
+  const db = b1 - b0;
+  return (t) => `#${toHex(r0 + dr * t)}${toHex(g0 + dg * t)}${toHex(b0 + db * t)}`;
+};
+var MAX_CACHE_SIZE = 64;
+var cache = /* @__PURE__ */ new Map();
+var interpolateColors = (colors) => {
+  const key = colors.join(",");
+  if (!cache.has(key)) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = cache.keys().next().value;
+      cache.delete(firstKey);
+    }
+    const C = colors.slice(0, -1).map((c, i) => interpolateColor(c, colors[i + 1]));
+    cache.set(key, C);
+  }
+  const interpolators = cache.get(key);
+  return (t) => {
+    const n = interpolators.length;
+    const j = Math.min(n - 1, Math.floor(t * n));
+    return interpolators[j](t * n - j);
+  };
+};
+
+// src/vector.ts
+var import_gl_matrix = require("gl-matrix");
+var slerp = (a, b) => {
+  const dot = import_gl_matrix.vec2.dot(a, b);
+  const clampedDot = Math.max(-1, Math.min(dot, 1));
+  const angle = Math.acos(clampedDot);
+  const sinAngle = Math.sin(angle);
+  const out = import_gl_matrix.vec2.clone(a);
+  if (angle === 0 || sinAngle === 0) return (_t) => out;
+  return (t) => {
+    const s1 = Math.sin((1 - t) * angle) / sinAngle;
+    const s2 = Math.sin(t * angle) / sinAngle;
+    out[0] = s1 * a[0] + s2 * b[0];
+    out[1] = s1 * a[1] + s2 * b[1];
+    return out;
+  };
+};
+var interpolateVec2 = (a, b) => {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const out = import_gl_matrix.vec2.create();
+  return (t) => {
+    out[0] = a[0] + dx * t;
+    out[1] = a[1] + dy * t;
+    return out;
+  };
+};
+var interpolateRotate = (a, b) => {
+  let d = b - a;
+  if (d > Math.PI) d -= 2 * Math.PI;
+  else if (d < -Math.PI) d += 2 * Math.PI;
+  return (t) => a + d * t;
+};
+
+// src/matrix.ts
+var import_gl_matrix2 = require("gl-matrix");
+var decompose = (mat) => {
+  const [a, b, c, d, e, f] = mat;
+  const translation = import_gl_matrix2.vec2.fromValues(e, f);
+  const scale = import_gl_matrix2.vec2.fromValues(Math.hypot(a, b), Math.hypot(c, d));
+  const rotation = Math.atan2(b, a);
+  return { translation, rotation, scale };
+};
+var interpolateMat2d = (a, b) => {
+  const { translation: ta, rotation: ra, scale: sa } = decompose(a);
+  const { translation: tb, rotation: rb, scale: sb } = decompose(b);
+  const is = interpolateVec2(sa, sb);
+  const ir = interpolateRotate(ra, rb);
+  const it = interpolateVec2(ta, tb);
+  const out = import_gl_matrix2.mat2d.create();
+  return (t) => {
+    const s = is(t);
+    const r = ir(t);
+    const p = it(t);
+    const cos = Math.cos(r);
+    const sin = Math.sin(r);
+    out[0] = cos * s[0];
+    out[1] = sin * s[0];
+    out[2] = -sin * s[1];
+    out[3] = cos * s[1];
+    out[4] = p[0];
+    out[5] = p[1];
+    return out;
+  };
+};
+
+// src/value.ts
+var interpolateValue = (a, b) => {
+  if (typeof a === "number" && typeof b === "number") return lerp(a, b);
+  if (typeof a === "string" && typeof b === "string") return interpolateColor(a, b);
+  return () => a;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decompose,
+  interpolateColor,
+  interpolateColors,
+  interpolateMat2d,
+  interpolateRotate,
+  interpolateValue,
+  interpolateVec2,
+  lerp,
+  normalize,
+  slerp
+});

package/dist/main.d.cts

@@ -0,0 +1,84 @@
+import { vec2, mat2d } from 'gl-matrix';
+
+/**
+ * 线性插值构造器，预计算差值，每次调用只需 1 乘 1 加
+ * @param a 起始值
+ * @param b 结束值
+ * @returns 插值函数 (t) => number
+ */
+declare const lerp: (a: number, b: number) => (t: number) => number;
+/**
+ * 归一化函数构造器，预计算倒数避免每次除法
+ * @param a 左界
+ * @param b 右界
+ * @returns 归一化函数
+ */
+declare const normalize: (a: number, b: number) => (x: number) => number;
+
+/**
+ * 根据插值系数 t 计算两个颜色的插值颜色构造器
+ * 预计算 RGB 差值，每次调用只需 3 次乘加 + 查表
+ * @param c0 起始颜色
+ * @param c1 结束颜色
+ * @returns 插值函数
+ */
+declare const interpolateColor: (c0: string, c1: string) => (t: number) => string;
+/**
+ * 根据颜色数组计算插值颜色函数构造器
+ * @param colors 颜色数组
+ * @returns 插值颜色函数
+ */
+declare const interpolateColors: (colors: string[]) => (t: number) => string;
+
+/**
+ * 球面二维向量插值构造器，预分配输出向量避免 GC
+ * @param a 向量 a
+ * @param b 向量 b
+ * @returns 插值函数 (t) => vec2（注意：返回的 vec2 是复用对象）
+ */
+declare const slerp: (a: vec2, b: vec2) => (_t: number) => vec2;
+/**
+ * 向量插值函数构造器
+ * 预计算差值 + 预分配输出 vec2，每次调用零分配
+ * @param a 向量
+ * @param b 向量
+ * @returns 插值函数 (t) => vec2（注意：返回的 vec2 是复用对象）
+ */
+declare const interpolateVec2: (a: vec2, b: vec2) => (t: number) => vec2;
+/**
+ * 角度插值函数构造器（最短路径）
+ * 直接计算最短角度差，避免 slerp 的三角函数开销
+ * @param a 起始角度（弧度）
+ * @param b 结束角度（弧度）
+ * @returns 插值函数 (t) => number
+ */
+declare const interpolateRotate: (a: number, b: number) => (t: number) => number;
+
+/**
+ * 解构矩阵为 TRS 分量
+ * @param mat 矩阵
+ * @returns 平移、旋转、缩放
+ */
+declare const decompose: (mat: mat2d) => {
+    translation: vec2;
+    rotation: number;
+    scale: vec2;
+};
+/**
+ * 插值矩阵函数构造器
+ * 预分配输出矩阵，每次调用复用同一对象
+ * @param a 起始矩阵
+ * @param b 结束矩阵
+ * @returns 插值矩阵函数 (t) => mat2d（注意：返回的 mat2d 是复用对象）
+ */
+declare const interpolateMat2d: (a: mat2d, b: mat2d) => (t: number) => mat2d;
+
+/**
+ * 通用插值函数构造器，根据类型自动分派
+ * @param a 起始值（number 或 color string）
+ * @param b 结束值
+ * @returns 插值函数
+ */
+declare const interpolateValue: (a: number | string, b: number | string) => ((t: number) => number) | ((t: number) => string) | (() => string | number);
+
+export { decompose, interpolateColor, interpolateColors, interpolateMat2d, interpolateRotate, interpolateValue, interpolateVec2, lerp, normalize, slerp };

package/dist/main.d.ts

@@ -0,0 +1,84 @@
+import { vec2, mat2d } from 'gl-matrix';
+
+/**
+ * 线性插值构造器，预计算差值，每次调用只需 1 乘 1 加
+ * @param a 起始值
+ * @param b 结束值
+ * @returns 插值函数 (t) => number
+ */
+declare const lerp: (a: number, b: number) => (t: number) => number;
+/**
+ * 归一化函数构造器，预计算倒数避免每次除法
+ * @param a 左界
+ * @param b 右界
+ * @returns 归一化函数
+ */
+declare const normalize: (a: number, b: number) => (x: number) => number;
+
+/**
+ * 根据插值系数 t 计算两个颜色的插值颜色构造器
+ * 预计算 RGB 差值，每次调用只需 3 次乘加 + 查表
+ * @param c0 起始颜色
+ * @param c1 结束颜色
+ * @returns 插值函数
+ */
+declare const interpolateColor: (c0: string, c1: string) => (t: number) => string;
+/**
+ * 根据颜色数组计算插值颜色函数构造器
+ * @param colors 颜色数组
+ * @returns 插值颜色函数
+ */
+declare const interpolateColors: (colors: string[]) => (t: number) => string;
+
+/**
+ * 球面二维向量插值构造器，预分配输出向量避免 GC
+ * @param a 向量 a
+ * @param b 向量 b
+ * @returns 插值函数 (t) => vec2（注意：返回的 vec2 是复用对象）
+ */
+declare const slerp: (a: vec2, b: vec2) => (_t: number) => vec2;
+/**
+ * 向量插值函数构造器
+ * 预计算差值 + 预分配输出 vec2，每次调用零分配
+ * @param a 向量
+ * @param b 向量
+ * @returns 插值函数 (t) => vec2（注意：返回的 vec2 是复用对象）
+ */
+declare const interpolateVec2: (a: vec2, b: vec2) => (t: number) => vec2;
+/**
+ * 角度插值函数构造器（最短路径）
+ * 直接计算最短角度差，避免 slerp 的三角函数开销
+ * @param a 起始角度（弧度）
+ * @param b 结束角度（弧度）
+ * @returns 插值函数 (t) => number
+ */
+declare const interpolateRotate: (a: number, b: number) => (t: number) => number;
+
+/**
+ * 解构矩阵为 TRS 分量
+ * @param mat 矩阵
+ * @returns 平移、旋转、缩放
+ */
+declare const decompose: (mat: mat2d) => {
+    translation: vec2;
+    rotation: number;
+    scale: vec2;
+};
+/**
+ * 插值矩阵函数构造器
+ * 预分配输出矩阵，每次调用复用同一对象
+ * @param a 起始矩阵
+ * @param b 结束矩阵
+ * @returns 插值矩阵函数 (t) => mat2d（注意：返回的 mat2d 是复用对象）
+ */
+declare const interpolateMat2d: (a: mat2d, b: mat2d) => (t: number) => mat2d;
+
+/**
+ * 通用插值函数构造器，根据类型自动分派
+ * @param a 起始值（number 或 color string）
+ * @param b 结束值
+ * @returns 插值函数
+ */
+declare const interpolateValue: (a: number | string, b: number | string) => ((t: number) => number) | ((t: number) => string) | (() => string | number);
+
+export { decompose, interpolateColor, interpolateColors, interpolateMat2d, interpolateRotate, interpolateValue, interpolateVec2, lerp, normalize, slerp };

package/dist/main.js

@@ -0,0 +1,141 @@
+// src/number.ts
+var lerp = (a, b) => {
+  const d = b - a;
+  return (t) => a + d * t;
+};
+var normalize = (a, b) => {
+  const d = b - a;
+  if (!d) return () => isNaN(d) ? NaN : 0.5;
+  const inv = 1 / d;
+  return (x) => (x - a) * inv;
+};
+
+// src/color.ts
+var HEX_REGEX = /^#([A-Fa-f0-9]{6})$/;
+var RGB_REGEX = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
+var parseColor = (color) => {
+  let match;
+  if (match = HEX_REGEX.exec(color)) {
+    const v = parseInt(match[1], 16);
+    return [v >> 16 & 255, v >> 8 & 255, v & 255];
+  }
+  if (match = RGB_REGEX.exec(color)) {
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+  }
+  throw new Error(`Unsupported color format: ${color}`);
+};
+var HEX_TABLE = new Array(256);
+for (let i = 0; i < 256; i++) HEX_TABLE[i] = i.toString(16).padStart(2, "0");
+var toHex = (n) => HEX_TABLE[n + 0.5 | 0];
+var interpolateColor = (c0, c1) => {
+  const [r0, g0, b0] = parseColor(c0);
+  const [r1, g1, b1] = parseColor(c1);
+  const dr = r1 - r0;
+  const dg = g1 - g0;
+  const db = b1 - b0;
+  return (t) => `#${toHex(r0 + dr * t)}${toHex(g0 + dg * t)}${toHex(b0 + db * t)}`;
+};
+var MAX_CACHE_SIZE = 64;
+var cache = /* @__PURE__ */ new Map();
+var interpolateColors = (colors) => {
+  const key = colors.join(",");
+  if (!cache.has(key)) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = cache.keys().next().value;
+      cache.delete(firstKey);
+    }
+    const C = colors.slice(0, -1).map((c, i) => interpolateColor(c, colors[i + 1]));
+    cache.set(key, C);
+  }
+  const interpolators = cache.get(key);
+  return (t) => {
+    const n = interpolators.length;
+    const j = Math.min(n - 1, Math.floor(t * n));
+    return interpolators[j](t * n - j);
+  };
+};
+
+// src/vector.ts
+import { vec2 } from "gl-matrix";
+var slerp = (a, b) => {
+  const dot = vec2.dot(a, b);
+  const clampedDot = Math.max(-1, Math.min(dot, 1));
+  const angle = Math.acos(clampedDot);
+  const sinAngle = Math.sin(angle);
+  const out = vec2.clone(a);
+  if (angle === 0 || sinAngle === 0) return (_t) => out;
+  return (t) => {
+    const s1 = Math.sin((1 - t) * angle) / sinAngle;
+    const s2 = Math.sin(t * angle) / sinAngle;
+    out[0] = s1 * a[0] + s2 * b[0];
+    out[1] = s1 * a[1] + s2 * b[1];
+    return out;
+  };
+};
+var interpolateVec2 = (a, b) => {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const out = vec2.create();
+  return (t) => {
+    out[0] = a[0] + dx * t;
+    out[1] = a[1] + dy * t;
+    return out;
+  };
+};
+var interpolateRotate = (a, b) => {
+  let d = b - a;
+  if (d > Math.PI) d -= 2 * Math.PI;
+  else if (d < -Math.PI) d += 2 * Math.PI;
+  return (t) => a + d * t;
+};
+
+// src/matrix.ts
+import { mat2d, vec2 as vec22 } from "gl-matrix";
+var decompose = (mat) => {
+  const [a, b, c, d, e, f] = mat;
+  const translation = vec22.fromValues(e, f);
+  const scale = vec22.fromValues(Math.hypot(a, b), Math.hypot(c, d));
+  const rotation = Math.atan2(b, a);
+  return { translation, rotation, scale };
+};
+var interpolateMat2d = (a, b) => {
+  const { translation: ta, rotation: ra, scale: sa } = decompose(a);
+  const { translation: tb, rotation: rb, scale: sb } = decompose(b);
+  const is = interpolateVec2(sa, sb);
+  const ir = interpolateRotate(ra, rb);
+  const it = interpolateVec2(ta, tb);
+  const out = mat2d.create();
+  return (t) => {
+    const s = is(t);
+    const r = ir(t);
+    const p = it(t);
+    const cos = Math.cos(r);
+    const sin = Math.sin(r);
+    out[0] = cos * s[0];
+    out[1] = sin * s[0];
+    out[2] = -sin * s[1];
+    out[3] = cos * s[1];
+    out[4] = p[0];
+    out[5] = p[1];
+    return out;
+  };
+};
+
+// src/value.ts
+var interpolateValue = (a, b) => {
+  if (typeof a === "number" && typeof b === "number") return lerp(a, b);
+  if (typeof a === "string" && typeof b === "string") return interpolateColor(a, b);
+  return () => a;
+};
+export {
+  decompose,
+  interpolateColor,
+  interpolateColors,
+  interpolateMat2d,
+  interpolateRotate,
+  interpolateValue,
+  interpolateVec2,
+  lerp,
+  normalize,
+  slerp
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rendx-interpolate",
+  "version": "0.1.0",
+  "description": "Interpolators for numbers, colors, vectors, and matrices",
+  "license": "MIT",
+  "author": "wei.liang (https://github.com/weiliang0121)",
+  "type": "module",
+  "keywords": [
+    "rendx",
+    "2d",
+    "canvas",
+    "rendering",
+    "visualization",
+    "scene-graph"
+  ],
+  "homepage": "https://weiliang0121.github.io/rendx/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/weiliang0121/rendx.git",
+    "directory": "packages/interpolate"
+  },
+  "main": "dist/main.cjs",
+  "module": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.js",
+      "require": "./dist/main.cjs"
+    }
+  },
+  "dependencies": {
+    "gl-matrix": "^3.4.4",
+    "rendx-core": "^0.1.0"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}