@derivesome/tools 1.0.1

package/src/array.ts

@@ -0,0 +1,176 @@
+import { type Triple, type Pair, V2, V3 } from "./types";
+
+export const range = (n: number): number[] =>
+  n <= 0 || typeof n !== "number" || isNaN(n) || !isFinite(n)
+    ? []
+    : Array.from(Array(Math.floor(n)).keys());
+
+export const zipMin = <A, B>(a: A[], b: B[]): Array<Pair<A, B>> =>
+  range(Math.min(a.length, b.length)).map((i): Pair<A, B> => {
+    const x = a[i]!;
+    const y = b[i]!;
+    return [x, y];
+  });
+
+export const zipMax = <A, B>(
+  a: A[],
+  b: B[],
+): Array<Pair<A | undefined, B | undefined>> =>
+  range(Math.min(a.length, b.length)).map(
+    (i): Pair<A | undefined, B | undefined> => {
+      const x = a[i];
+      const y = b[i];
+      return [x, y];
+    },
+  );
+
+export function toBatched<T>(arr: T[], batchSize: 1, padding: T): Array<[T]>;
+export function toBatched<T>(arr: T[], batchSize: 2, padding: T): Array<[T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 3,
+  padding: T,
+): Array<[T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 4,
+  padding: T,
+): Array<[T, T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 5,
+  padding: T,
+): Array<[T, T, T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 6,
+  padding: T,
+): Array<[T, T, T, T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 7,
+  padding: T,
+): Array<[T, T, T, T, T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: 8,
+  padding: T,
+): Array<[T, T, T, T, T, T, T, T]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: number,
+  padding: T,
+): Array<T[]>;
+export function toBatched<T>(arr: T[], batchSize: number): Array<T[]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: number,
+  padding?: T,
+): Array<T[]>;
+export function toBatched<T>(
+  arr: T[],
+  batchSize: number,
+  padding?: T,
+): Array<T[]> {
+  const output: Array<T[]> = [];
+
+  for (let i = 0; i < arr.length; i += batchSize) {
+    const batch = arr.slice(i, i + batchSize);
+    if (padding !== undefined && batch.length < batchSize) {
+      batch.push(...Array<T>(batchSize - batch.length).fill(padding));
+    }
+    output.push(batch);
+  }
+
+  return output;
+}
+
+export const sum = (arr: number[]): number => arr.reduce((a, b) => a + b, 0);
+
+export const average = (arr: number[]): number =>
+  arr.length <= 0 ? 0 : sum(arr) / arr.length;
+
+export const magnitude = (arr: number[]): number => Math.hypot(...arr);
+
+export const normalizeSq = <Arr extends number[]>(arr: Arr): Arr => {
+  const mag = magnitude(arr);
+  if (Math.abs(mag) < 0.00000000000000001) return [...arr] as Arr;
+  return arr.map((x) => x / mag) as Arr;
+};
+
+// alias for normalizeSq
+export const unit = <Arr extends number[]>(arr: Arr): Arr => normalizeSq(arr);
+
+export const dot = (a: number[], b: number[]): number =>
+  sum(zipMin(a, b).map(([v1, v2]) => v1 * v2));
+
+export const cross = (
+  a: number[] | Triple<number, number, number>,
+  b: number[] | Triple<number, number, number>,
+): Triple<number, number, number> => {
+  if (a.length !== 3)
+    throw new Error("cross() can only be used on 3-dimensional vectors");
+  if (b.length !== a.length)
+    throw new Error("both vectors must have the same length");
+
+  const ax = a[0]!;
+  const ay = a[1]!;
+  const az = a[2]!;
+
+  const bx = a[0]!;
+  const by = a[1]!;
+  const bz = a[2]!;
+
+  const x = ay * bz - az * by;
+  const y = az * bx - ax * bz;
+  const z = ax * by - ay * bx;
+
+  return [x, y, z];
+};
+
+export function add(a: V2, b: V2): V2;
+export function add(a: V3, b: V3): V3;
+export function add(a: number[], b: number[]): number[];
+export function add(a: number[], b: number[]): number[] {
+  return zipMin(a, b).map(([v1, v2]) => v1 + v2);
+}
+
+export function sub(a: V2, b: V2): V2;
+export function sub(a: V3, b: V3): V3;
+export function sub(a: number[], b: number[]): number[];
+export function sub(a: number[], b: number[]): number[] {
+  return zipMin(a, b).map(([v1, v2]) => v1 - v2);
+}
+
+export function mul(a: V2, b: V2): V2;
+export function mul(a: V3, b: V3): V3;
+export function mul(a: number[], b: number[]): number[];
+export function mul(a: number[], b: number[]): number[] {
+  return zipMin(a, b).map(([v1, v2]) => v1 * v2);
+}
+
+export function div(a: V2, b: V2): V2;
+export function div(a: V3, b: V3): V3;
+export function div(a: number[], b: number[]): number[];
+export function div(a: number[], b: number[]): number[] {
+  return zipMin(a, b).map(([v1, v2]) => v1 / v2);
+}
+
+export function scale(a: V2, s: number): V2;
+export function scale(a: V3, s: number): V3;
+export function scale(a: number[], s: number): number[];
+export function scale(a: number[], s: number): number[] {
+  return a.map((v) => v * s);
+}
+
+export const distance = (a: number[], b: number[]): number =>
+  magnitude(sub(b, a));
+
+export const cosineDistance = (a: number[], b: number[]): number => {
+  const dp = dot(a, b);
+  const magA = magnitude(a);
+  const magB = magnitude(b);
+  const result = dp / (magA * magB);
+  if (isNaN(result) || !isFinite(result)) return 0;
+  return result;
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./scalar";
+export * from "./array";
+export * from "./url";

package/src/index.ts~

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './scalar';
+export * from './array';
+export * from './url';

package/src/scalar.ts

@@ -0,0 +1,72 @@
+export const clamp = (x: number, min: number, max: number): number =>
+  Math.max(min, Math.min(max, x));
+
+export const lerp = (vFrom: number, vTo: number, scale: number) =>
+  vFrom + (vTo - vFrom) * scale;
+
+export const remap = (
+  x: number,
+  range1: [number, number],
+  range2: [number, number],
+): number => {
+  const min1 = range1[0];
+  const max1 = range1[1];
+  const min2 = range2[0];
+  const max2 = range2[1];
+  const div = max1 - min1;
+
+  if (Math.abs(div) <= 0.00000000000000000001) return min2;
+
+  return min2 + ((clamp(x, min1, max1) - min1) / div) * (max2 - min2);
+};
+
+export const smoothstep = (
+  edge0: number,
+  edge1: number,
+  value: number,
+): number => {
+  const x = clamp((value - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * (3.0 - 2.0 * x);
+};
+
+/**
+ * Smooth greater-than
+ */
+export const sgt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (a - b)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth less-than
+ */
+export const slt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth minimum
+ */
+export const smin = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) - k * h * (1.0 - h);
+};
+
+/**
+ * Smooth maximum
+ */
+export const smax = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) + k * h * (1.0 - h);
+};
+
+export const fract = (x: number) => x - Math.floor(x);
+
+/**
+ * Absolute modulus
+ */
+export const amod = (value: number, modulus: number): number =>
+  ((value % modulus) + modulus) % modulus;
+
+export const sigmoid = (x: number) => 1 / (1 + Math.exp(-x));

package/src/scalar.ts~

@@ -0,0 +1,72 @@
+export const clamp = (x: number, min: number, max: number): number =>
+  Math.max(min, Math.min(max, x));
+
+export const lerp = (vFrom: number, vTo: number, scale: number) =>
+  vFrom + (vTo - vFrom) * scale;
+
+export const remap = (
+  x: number,
+  range1: [number, number],
+  range2: [number, number],
+): number => {
+  const min1 = range1[0];
+  const max1 = range1[1];
+  const min2 = range2[0];
+  const max2 = range2[1];
+  const div = max1 - min1;
+
+  if (Math.abs(div) <= 0.00000000000000000001) return min2;
+
+  return min2 + ((clamp(x, min1, max1) - min1) / div) * (max2 - min2);
+};
+
+export const smoothstep = (
+  edge0: number,
+  edge1: number,
+  value: number,
+): number => {
+  const x = clamp((value - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * (3.0 - 2.0 * x);
+};
+
+/**
+ * Smooth greater-than
+ */
+export const sgt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (a - b)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth less-than
+ */
+export const slt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth minimum
+ */
+export const smin = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) - k * h * (1.0 - h);
+};
+
+/**
+ * Smooth maximum
+ */
+export const smax = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) + k * h * (1.0 - h);
+};
+
+export const fract = (x: number) => x - Math.floor(x);
+
+/**
+ * Absolute modulus
+ */
+export const amod = (value: number, modulus: number): number =>
+  ((value % modulus) + modulus) % modulus;
+
+export const sigmoid = (x: number) => 1 / (1 + Math.exp(-x));

package/src/types.ts

@@ -0,0 +1,14 @@
+export type Pair<A, B> = [A, B];
+export type Triple<A, B, C> = [A, B, C];
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type V2 = [number, number];
+export type V3 = [number, number, number];
+export type V4 = [number, number, number, number];
+
+export type TupleOf<T> = [T, ...T[]] | [...T[], T] | [T];
+
+export type Arrayish<T> = TupleOf<T> | Array<T>;

package/src/url.ts

@@ -0,0 +1,5 @@
+export const urlEncode = <T extends Record<string, unknown>>(
+  params: T,
+): string => {
+  return new URLSearchParams(params as Record<string, string>).toString();
+};

package/src/url.ts~

@@ -0,0 +1,5 @@
+export const urlEncode = <T extends Record<string, unknown>>(
+  params: T,
+): string => {
+  return new URLSearchParams(params as Record<string, string>).toString();
+};

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "commonjs",
+    "moduleResolution": "node10"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "nodenext",
+    "target": "esnext"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext", "es2020"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}

package/tsconfig.json~

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}