@audio-ui/utils 0.0.1

package/.turbo/turbo-build$colon$pkg.log

@@ -0,0 +1,15 @@
+
+$ tsup
+CLI Building entry: {"index":"src/index.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/lucienloua/Desktop/audio-ui/packages/utils/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js     9.31 KB
+ESM dist/index.js.map 20.40 KB
+ESM ⚡️ Build success in 18ms
+DTS Build start
+DTS ⚡️ Build success in 1684ms
+DTS dist/index.d.ts 5.34 KB

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @audio-ui/utils
+
+## 0.0.1
+
+### Patch Changes
+
+- e649721: init

package/README.md

@@ -0,0 +1,3 @@
+# `@audio-ui/utils`
+
+A collection of utility functions for Audio UI.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@audio-ui/utils",
+  "version": "0.0.1",
+  "description": "A collection of utility functions for Audio UI.",
+  "license": "MIT",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ouestlabs/audio-ui.git",
+    "directory": "packages/utils"
+  },
+  "homepage": "https://github.com/ouestlabs/audio-ui/tree/main/packages/utils",
+  "bugs": {
+    "url": "https://github.com/ouestlabs/audio-ui/issues"
+  },
+  "keywords": [
+    "audio-ui",
+    "utils"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./dom": {
+      "types": "./dist/dom/index.d.ts",
+      "import": "./dist/dom/index.js"
+    }
+  },
+  "scripts": {
+    "build:pkg": "tsup",
+    "dev": "tsup --watch"
+  },
+  "devDependencies": {
+    "@audio-ui/typescript": "workspace:*",
+    "@types/bun": "latest",
+    "tsup": "^8.5.0"
+  }
+}

package/src/geom.ts

@@ -0,0 +1,335 @@
+import { clamp } from "./math";
+import { type int, Unhandled } from "./std";
+
+export type Point = { x: number; y: number };
+export type Circle = Point & { r: number };
+export type Size = { width: number; height: number };
+export type Rect = Point & Size;
+export type Padding = [number, number, number, number];
+export type Client = { clientX: number; clientY: number };
+
+export enum Axis {
+  T = 0,
+  R = 1,
+  B = 2,
+  L = 3,
+}
+
+export enum Corner {
+  TL = 0,
+  TR = 1,
+  BR = 2,
+  BL = 3,
+}
+
+export namespace Geom {
+  export const outerTangentPoints = (a: Circle, b: Circle): [Point, Point] => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const angle =
+      Math.atan2(dy, dx) +
+      Math.acos((a.r - b.r) / Math.sqrt(dx * dx + dy * dy));
+    const cs = Math.cos(angle);
+    const sn = Math.sin(angle);
+    return [
+      { x: a.x + a.r * cs, y: a.y + a.r * sn },
+      { x: b.x + b.r * cs, y: b.y + b.r * sn },
+    ];
+  };
+}
+
+export namespace Point {
+  export const zero = (): Point => ({ x: 0, y: 0 });
+  export const create = (x: number, y: number): Point => ({ x, y });
+  export const clone = (point: Point): Point => ({ ...point });
+  export const floor = (point: Point): Point => ({
+    x: Math.floor(point.x),
+    y: Math.floor(point.y),
+  });
+  export const length = (point: Point): number =>
+    Math.sqrt(point.x * point.x + point.y * point.y);
+  export const distance = (a: Point, b: Point): number =>
+    Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  export const add = (a: Point, b: Point): Point => ({
+    x: a.x + b.x,
+    y: a.y + b.y,
+  });
+  export const subtract = (a: Point, b: Point): Point => ({
+    x: a.x - b.x,
+    y: a.y - b.y,
+  });
+  export const scaleBy = (point: Point, scale: number): Point => ({
+    x: point.x * scale,
+    y: point.y * scale,
+  });
+  export const scaleTo = (point: Point, scale: number): Point => {
+    const multiplier = scale / length(point);
+    return { x: point.x * multiplier, y: point.y * multiplier };
+  };
+  export const fromClient = (object: {
+    clientX: number;
+    clientY: number;
+  }): Point => ({
+    x: object.clientX,
+    y: object.clientY,
+  });
+}
+
+export namespace Rect {
+  export const Empty: Readonly<Rect> = Object.freeze({
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+  });
+
+  export const corners = (rectangle: Rect): Array<Point> => {
+    const x0 = rectangle.x;
+    const y0 = rectangle.y;
+    const x1 = x0 + rectangle.width;
+    const y1 = y0 + rectangle.height;
+    return [
+      { x: x0, y: y0 },
+      { x: x1, y: y0 },
+      { x: x1, y: y1 },
+      { x: x0, y: y1 },
+    ];
+  };
+
+  export const inflate = (rect: Rect, amount: number): Rect => ({
+    x: rect.x - amount,
+    y: rect.y - amount,
+    width: rect.width + amount * 2.0,
+    height: rect.height + amount * 2.0,
+  });
+
+  export const contains = (outer: Rect, inner: Rect): boolean => {
+    const topLeftInside = inner.x >= outer.x && inner.y >= outer.y;
+    const bottomRightInside =
+      inner.x + inner.width <= outer.x + outer.width &&
+      inner.y + inner.height <= outer.y + outer.height;
+    return topLeftInside && bottomRightInside;
+  };
+
+  export const isPointInside = (point: Point, rect: Rect): boolean =>
+    point.x >= rect.x &&
+    point.x <= rect.x + rect.width &&
+    point.y >= rect.y &&
+    point.y <= rect.y + rect.height;
+
+  export const intersect = (a: Rect, b: Rect): boolean => {
+    const xMin = Math.max(a.x, b.x);
+    const xMax = Math.min(a.x + a.width, b.x + b.width);
+    const yMax = Math.min(a.y + a.height, b.y + b.height);
+    const yMin = Math.max(a.y, b.y);
+    return xMax > xMin && yMax > yMin;
+  };
+
+  export const axis = (rectangle: Rect, axisValue: Axis): number => {
+    switch (axisValue) {
+      case Axis.T:
+        return rectangle.y;
+      case Axis.R:
+        return rectangle.x + rectangle.width;
+      case Axis.B:
+        return rectangle.y + rectangle.height;
+      case Axis.L:
+        return rectangle.x;
+      default:
+        return Unhandled(axisValue);
+    }
+  };
+
+  export const corner = (rectangle: Rect, cornerValue: Corner): Point => {
+    switch (cornerValue) {
+      case Corner.TL:
+        return { x: rectangle.x, y: rectangle.y };
+      case Corner.TR:
+        return { x: rectangle.x + rectangle.width, y: rectangle.y };
+      case Corner.BR:
+        return {
+          x: rectangle.x + rectangle.width,
+          y: rectangle.y + rectangle.height,
+        };
+      case Corner.BL:
+        return { x: rectangle.x, y: rectangle.y + rectangle.height };
+      default:
+        return Unhandled(cornerValue);
+    }
+  };
+
+  export const center = (rectangle: Rect): Point => ({
+    x: rectangle.x + rectangle.width * 0.5,
+    y: rectangle.y + rectangle.height * 0.5,
+  });
+
+  export const isEmpty = (rectangle: Rect): boolean =>
+    rectangle.width === 0 || rectangle.height === 0;
+
+  export const union = (a: Rect, b: Readonly<Rect>): void => {
+    if (Rect.isEmpty(a)) {
+      if (!Rect.isEmpty(b)) {
+        a.x = b.x;
+        a.y = b.y;
+        a.width = b.width;
+        a.height = b.height;
+      }
+    } else if (!Rect.isEmpty(b)) {
+      const bx = b.x;
+      const by = b.y;
+      const ux = Math.min(a.x, bx);
+      const uy = Math.min(a.y, by);
+      a.width = Math.max(a.x + a.width, bx + b.width) - ux;
+      a.height = Math.max(a.y + a.height, by + b.height) - uy;
+      a.x = ux;
+      a.y = uy;
+    }
+  };
+}
+
+export interface AABB {
+  xMin: number;
+  xMax: number;
+  yMin: number;
+  yMax: number;
+}
+
+export namespace AABB {
+  export const width = (aabb: AABB): number => aabb.xMax - aabb.xMin;
+  export const height = (aabb: AABB): number => aabb.yMax - aabb.yMin;
+
+  export const from = (aabb: AABB, that: AABB): void => {
+    aabb.xMin = that.xMin;
+    aabb.xMax = that.xMax;
+    aabb.yMin = that.yMin;
+    aabb.yMax = that.yMax;
+  };
+
+  export const extend = (aabb: AABB, offset: number): void => {
+    aabb.xMin -= offset;
+    aabb.yMin -= offset;
+    aabb.xMax += offset;
+    aabb.yMax += offset;
+  };
+
+  export const padding = (
+    aabb: AABB,
+    [top, right, bottom, left]: Readonly<Padding>
+  ): AABB => {
+    aabb.xMin += left;
+    aabb.yMin += top;
+    aabb.xMax -= right;
+    aabb.yMax -= bottom;
+    return aabb;
+  };
+
+  export const intersectPoint = (aabb: AABB, point: Point): boolean =>
+    aabb.xMin <= point.x &&
+    point.x < aabb.xMax &&
+    aabb.yMin <= point.y &&
+    point.y < aabb.yMax;
+
+  export const intersectThat = (aabb: AABB, that: AABB): boolean =>
+    that.xMin < aabb.xMax &&
+    that.xMax > aabb.xMin &&
+    that.yMin < aabb.yMax &&
+    that.yMax > aabb.yMin;
+
+  export const center = (aabb: AABB): Point => ({
+    x: (aabb.xMin + aabb.xMax) * 0.5,
+    y: (aabb.yMin + aabb.yMax) * 0.5,
+  });
+}
+
+export namespace Padding {
+  export const Identity: Readonly<Padding> = Object.freeze([
+    0.0, 0.0, 0.0, 0.0,
+  ]);
+}
+
+export namespace CohenSutherland {
+  export const intersects = (
+    xMin: number,
+    xMax: number,
+    yMin: number,
+    yMax: number,
+    x0: number,
+    y0: number,
+    x1: number,
+    y1: number
+  ): boolean => {
+    const c0 = code(xMin, xMax, yMin, yMax, x0, y0);
+    const c1 = code(xMin, xMax, yMin, yMax, x1, y1);
+    if ((c0 | c1) === 0) {
+      return false;
+    }
+    if ((c0 & c1) !== 0) {
+      return false;
+    }
+    const s = sign(x0, y0, x1, y1, xMin, yMin);
+    return (
+      s !== sign(x0, y0, x1, y1, xMax, yMin) ||
+      s !== sign(x0, y0, x1, y1, xMax, yMax) ||
+      s !== sign(x0, y0, x1, y1, xMin, yMax)
+    );
+  };
+
+  const code = (
+    xMin: number,
+    xMax: number,
+    yMin: number,
+    yMax: number,
+    x: number,
+    y: number
+  ): int => {
+    let codeValue = 0;
+    if (x <= xMin) {
+      codeValue |= 1;
+    } else if (x >= xMax) {
+      codeValue |= 2;
+    }
+    if (y <= yMin) {
+      codeValue |= 8;
+    } else if (y >= yMax) {
+      codeValue |= 4;
+    }
+    return codeValue;
+  };
+
+  const sign = (
+    x0: number,
+    y0: number,
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number
+  ): boolean => (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0) >= 0;
+}
+
+export interface ValueAxis {
+  valueToAxis(value: number): number;
+  axisToValue(axis: number): number;
+}
+
+export namespace ValueAxis {
+  export const Identity: ValueAxis = {
+    valueToAxis: (value: number): number => value,
+    axisToValue: (axis: number): number => axis,
+  };
+
+  export const toClamped = (
+    valueAxis: ValueAxis,
+    min: number,
+    max: number
+  ): ValueAxis => ({
+    valueToAxis: (value: number): number =>
+      valueAxis.valueToAxis(clamp(value, min, max)),
+    axisToValue: (axis: number): number =>
+      clamp(valueAxis.axisToValue(axis), min, max),
+  });
+
+  export const createClamped = (min: number, max: number): ValueAxis => ({
+    valueToAxis: (value: number): number => clamp(value, min, max),
+    axisToValue: (axis: number): number => clamp(axis, min, max),
+  });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./geom";
+export * from "./math";
+export * from "./std";

package/src/math.ts

@@ -0,0 +1,34 @@
+import type { int, unitValue } from "./std";
+
+export const TAU = Math.PI * 2.0;
+export const PI_HALF = Math.PI / 2.0;
+export const PI_QUART = Math.PI / 4.0;
+export const INVERSE_SQRT_2 = 1.0 / Math.sqrt(2.0);
+
+export const clamp = (value: number, min: number, max: number): number =>
+  Math.max(min, Math.min(value, max));
+export const clampUnit = (value: number): unitValue =>
+  Math.max(0.0, Math.min(value, 1.0));
+export const squashUnit = (value: unitValue, margin: unitValue): unitValue =>
+  margin + (1.0 - 2.0 * margin) * Math.max(0.0, Math.min(value, 1.0));
+export const quantizeFloor = (value: number, interval: number): number =>
+  Math.floor(value / interval) * interval;
+export const quantizeCeil = (value: number, interval: number): number =>
+  Math.ceil(value / interval) * interval;
+export const quantizeRound = (value: number, interval: number): number =>
+  Math.round(value / interval) * interval;
+export const linear = (y1: number, y2: number, mu: number): number =>
+  y1 + (y2 - y1) * mu;
+export const exponential = (y1: number, y2: number, mu: number): number =>
+  y1 * (y2 / y1) ** mu;
+export const cosine = (y1: number, y2: number, mu: number): number => {
+  const mu2 = (1.0 - Math.cos(mu * Math.PI)) * 0.5;
+  return y1 * (1.0 - mu2) + y2 * mu2;
+};
+export const mod = (value: number, range: number): number =>
+  fract(value / range) * range;
+export const fract = (value: number): number => value - Math.floor(value);
+export const nextPowOf2 = (n: int): int =>
+  2 ** Math.ceil(Math.log(n) / Math.log(2));
+export const radToDeg = (rad: number): number => (rad * 180.0) / Math.PI;
+export const degToRad = (deg: number): number => (deg / 180.0) * Math.PI;

package/src/std.ts

@@ -0,0 +1,49 @@
+export type int = number;
+export type unitValue = number; // 0...1
+export type Optional<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type Maybe<T> = T | undefined | null;
+export type ValueOrProvider<T> = T | (() => T);
+export type Procedure<T> = (value: T) => void;
+export type Func<U, T> = (value: U) => T;
+export type AnyFunc = (...args: any[]) => any;
+export type AssertType<T> = (value: unknown) => value is T;
+export type Exec = () => void;
+
+export const isDefined = <T>(value: Maybe<T>): value is T =>
+  value !== undefined && value !== null;
+
+export const isUndefined = (value: unknown): value is undefined =>
+  value === undefined;
+
+export const isNotUndefined = <T>(value: Optional<T>): value is T =>
+  value !== undefined;
+
+export const asDefined = <T>(
+  value: Maybe<T>,
+  fail: ValueOrProvider<string> = "asDefined failed"
+): T =>
+  value === null || value === undefined ? panic(getOrProvide(fail)) : value;
+
+export const Unhandled = <R>(empty: never): R => {
+  throw new Error(`Unhandled ${empty}`);
+};
+
+export const panic = (issue?: string | Error | unknown): never => {
+  throw typeof issue === "string" ? new Error(issue) : issue;
+};
+
+export const getOrProvide = <T>(value: ValueOrProvider<T>): T =>
+  value instanceof Function ? value() : value;
+
+export const EmptyExec: Exec = (): void => {
+  // no-op
+};
+
+export const EmptyProcedure: Procedure<any> = (_: any): void => {
+  // no-op
+};
+
+export function assertType<T>(_value: unknown): asserts _value is T {
+  // no-op
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@audio-ui/typescript/base.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"]
+  },
+  "exclude": ["dist", "node_modules"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+  },
+  format: ["esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+});