@audio-ui/utils 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+type Circle = Point & {
+    r: number;
+};
+type Size = {
+    width: number;
+    height: number;
+};
+type Client = {
+    clientX: number;
+    clientY: number;
+};
+declare enum Axis {
+    T = 0,
+    R = 1,
+    B = 2,
+    L = 3
+}
+declare enum Corner {
+    TL = 0,
+    TR = 1,
+    BR = 2,
+    BL = 3
+}
+declare namespace Geom {
+    const outerTangentPoints: (a: Circle, b: Circle) => [Point, Point];
+}
+type Point = {
+    x: number;
+    y: number;
+};
+declare namespace Point {
+    const zero: () => Point;
+    const create: (x: number, y: number) => Point;
+    const clone: (point: Point) => Point;
+    const floor: (point: Point) => Point;
+    const length: (point: Point) => number;
+    const distance: (a: Point, b: Point) => number;
+    const add: (a: Point, b: Point) => Point;
+    const subtract: (a: Point, b: Point) => Point;
+    const scaleBy: (point: Point, scale: number) => Point;
+    const scaleTo: (point: Point, scale: number) => Point;
+    const fromClient: (object: {
+        clientX: number;
+        clientY: number;
+    }) => Point;
+}
+type Rect = Point & Size;
+declare namespace Rect {
+    const Empty: Readonly<Rect>;
+    const corners: (rectangle: Rect) => Array<Point>;
+    const inflate: (rect: Rect, amount: number) => Rect;
+    const contains: (outer: Rect, inner: Rect) => boolean;
+    const isPointInside: (point: Point, rect: Rect) => boolean;
+    const intersect: (a: Rect, b: Rect) => boolean;
+    const axis: (rectangle: Rect, axisValue: Axis) => number;
+    const corner: (rectangle: Rect, cornerValue: Corner) => Point;
+    const center: (rectangle: Rect) => Point;
+    const isEmpty: (rectangle: Rect) => boolean;
+    const union: (a: Rect, b: Readonly<Rect>) => void;
+}
+interface AABB {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+declare namespace AABB {
+    const width: (aabb: AABB) => number;
+    const height: (aabb: AABB) => number;
+    const from: (aabb: AABB, that: AABB) => void;
+    const extend: (aabb: AABB, offset: number) => void;
+    const padding: (aabb: AABB, [top, right, bottom, left]: Readonly<Padding>) => AABB;
+    const intersectPoint: (aabb: AABB, point: Point) => boolean;
+    const intersectThat: (aabb: AABB, that: AABB) => boolean;
+    const center: (aabb: AABB) => Point;
+}
+type Padding = [number, number, number, number];
+declare namespace Padding {
+    const Identity: Readonly<Padding>;
+}
+declare namespace CohenSutherland {
+    const intersects: (xMin: number, xMax: number, yMin: number, yMax: number, x0: number, y0: number, x1: number, y1: number) => boolean;
+}
+interface ValueAxis {
+    valueToAxis(value: number): number;
+    axisToValue(axis: number): number;
+}
+declare namespace ValueAxis {
+    const Identity: ValueAxis;
+    const toClamped: (valueAxis: ValueAxis, min: number, max: number) => ValueAxis;
+    const createClamped: (min: number, max: number) => ValueAxis;
+}
+
+type int = number;
+type unitValue = number;
+type Optional<T> = T | undefined;
+type Nullable<T> = T | null;
+type Maybe<T> = T | undefined | null;
+type ValueOrProvider<T> = T | (() => T);
+type Procedure<T> = (value: T) => void;
+type Func<U, T> = (value: U) => T;
+type AnyFunc = (...args: any[]) => any;
+type AssertType<T> = (value: unknown) => value is T;
+type Exec = () => void;
+declare const isDefined: <T>(value: Maybe<T>) => value is T;
+declare const isUndefined: (value: unknown) => value is undefined;
+declare const isNotUndefined: <T>(value: Optional<T>) => value is T;
+declare const asDefined: <T>(value: Maybe<T>, fail?: ValueOrProvider<string>) => T;
+declare const Unhandled: <R>(empty: never) => R;
+declare const panic: (issue?: string | Error | unknown) => never;
+declare const getOrProvide: <T>(value: ValueOrProvider<T>) => T;
+declare const EmptyExec: Exec;
+declare const EmptyProcedure: Procedure<any>;
+declare function assertType<T>(_value: unknown): asserts _value is T;
+
+declare const TAU: number;
+declare const PI_HALF: number;
+declare const PI_QUART: number;
+declare const INVERSE_SQRT_2: number;
+declare const clamp: (value: number, min: number, max: number) => number;
+declare const clampUnit: (value: number) => unitValue;
+declare const squashUnit: (value: unitValue, margin: unitValue) => unitValue;
+declare const quantizeFloor: (value: number, interval: number) => number;
+declare const quantizeCeil: (value: number, interval: number) => number;
+declare const quantizeRound: (value: number, interval: number) => number;
+declare const linear: (y1: number, y2: number, mu: number) => number;
+declare const exponential: (y1: number, y2: number, mu: number) => number;
+declare const cosine: (y1: number, y2: number, mu: number) => number;
+declare const mod: (value: number, range: number) => number;
+declare const fract: (value: number) => number;
+declare const nextPowOf2: (n: int) => int;
+declare const radToDeg: (rad: number) => number;
+declare const degToRad: (deg: number) => number;
+
+export { AABB, type AnyFunc, type AssertType, Axis, type Circle, type Client, CohenSutherland, Corner, EmptyExec, EmptyProcedure, type Exec, type Func, Geom, INVERSE_SQRT_2, type Maybe, type Nullable, type Optional, PI_HALF, PI_QUART, Padding, Point, type Procedure, Rect, type Size, TAU, Unhandled, ValueAxis, type ValueOrProvider, asDefined, assertType, clamp, clampUnit, cosine, degToRad, exponential, fract, getOrProvide, type int, isDefined, isNotUndefined, isUndefined, linear, mod, nextPowOf2, panic, quantizeCeil, quantizeFloor, quantizeRound, radToDeg, squashUnit, type unitValue };

package/dist/index.js

@@ -0,0 +1,322 @@
+// src/math.ts
+var TAU = Math.PI * 2;
+var PI_HALF = Math.PI / 2;
+var PI_QUART = Math.PI / 4;
+var INVERSE_SQRT_2 = 1 / Math.sqrt(2);
+var clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+var clampUnit = (value) => Math.max(0, Math.min(value, 1));
+var squashUnit = (value, margin) => margin + (1 - 2 * margin) * Math.max(0, Math.min(value, 1));
+var quantizeFloor = (value, interval) => Math.floor(value / interval) * interval;
+var quantizeCeil = (value, interval) => Math.ceil(value / interval) * interval;
+var quantizeRound = (value, interval) => Math.round(value / interval) * interval;
+var linear = (y1, y2, mu) => y1 + (y2 - y1) * mu;
+var exponential = (y1, y2, mu) => y1 * (y2 / y1) ** mu;
+var cosine = (y1, y2, mu) => {
+  const mu2 = (1 - Math.cos(mu * Math.PI)) * 0.5;
+  return y1 * (1 - mu2) + y2 * mu2;
+};
+var mod = (value, range) => fract(value / range) * range;
+var fract = (value) => value - Math.floor(value);
+var nextPowOf2 = (n) => 2 ** Math.ceil(Math.log(n) / Math.log(2));
+var radToDeg = (rad) => rad * 180 / Math.PI;
+var degToRad = (deg) => deg / 180 * Math.PI;
+
+// src/std.ts
+var isDefined = (value) => value !== void 0 && value !== null;
+var isUndefined = (value) => value === void 0;
+var isNotUndefined = (value) => value !== void 0;
+var asDefined = (value, fail = "asDefined failed") => value === null || value === void 0 ? panic(getOrProvide(fail)) : value;
+var Unhandled = (empty) => {
+  throw new Error(`Unhandled ${empty}`);
+};
+var panic = (issue) => {
+  throw typeof issue === "string" ? new Error(issue) : issue;
+};
+var getOrProvide = (value) => value instanceof Function ? value() : value;
+var EmptyExec = () => {
+};
+var EmptyProcedure = (_) => {
+};
+function assertType(_value) {
+}
+
+// src/geom.ts
+var Axis = /* @__PURE__ */ ((Axis2) => {
+  Axis2[Axis2["T"] = 0] = "T";
+  Axis2[Axis2["R"] = 1] = "R";
+  Axis2[Axis2["B"] = 2] = "B";
+  Axis2[Axis2["L"] = 3] = "L";
+  return Axis2;
+})(Axis || {});
+var Corner = /* @__PURE__ */ ((Corner2) => {
+  Corner2[Corner2["TL"] = 0] = "TL";
+  Corner2[Corner2["TR"] = 1] = "TR";
+  Corner2[Corner2["BR"] = 2] = "BR";
+  Corner2[Corner2["BL"] = 3] = "BL";
+  return Corner2;
+})(Corner || {});
+var Geom;
+((Geom2) => {
+  Geom2.outerTangentPoints = (a, b) => {
+    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 }
+    ];
+  };
+})(Geom || (Geom = {}));
+var Point;
+((Point2) => {
+  Point2.zero = () => ({ x: 0, y: 0 });
+  Point2.create = (x, y) => ({ x, y });
+  Point2.clone = (point) => ({ ...point });
+  Point2.floor = (point) => ({
+    x: Math.floor(point.x),
+    y: Math.floor(point.y)
+  });
+  Point2.length = (point) => Math.sqrt(point.x * point.x + point.y * point.y);
+  Point2.distance = (a, b) => Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  Point2.add = (a, b) => ({
+    x: a.x + b.x,
+    y: a.y + b.y
+  });
+  Point2.subtract = (a, b) => ({
+    x: a.x - b.x,
+    y: a.y - b.y
+  });
+  Point2.scaleBy = (point, scale) => ({
+    x: point.x * scale,
+    y: point.y * scale
+  });
+  Point2.scaleTo = (point, scale) => {
+    const multiplier = scale / (0, Point2.length)(point);
+    return { x: point.x * multiplier, y: point.y * multiplier };
+  };
+  Point2.fromClient = (object) => ({
+    x: object.clientX,
+    y: object.clientY
+  });
+})(Point || (Point = {}));
+var Rect;
+((Rect2) => {
+  Rect2.Empty = Object.freeze({
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  });
+  Rect2.corners = (rectangle) => {
+    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 }
+    ];
+  };
+  Rect2.inflate = (rect, amount) => ({
+    x: rect.x - amount,
+    y: rect.y - amount,
+    width: rect.width + amount * 2,
+    height: rect.height + amount * 2
+  });
+  Rect2.contains = (outer, inner) => {
+    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;
+  };
+  Rect2.isPointInside = (point, rect) => point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+  Rect2.intersect = (a, b) => {
+    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;
+  };
+  Rect2.axis = (rectangle, axisValue) => {
+    switch (axisValue) {
+      case 0 /* T */:
+        return rectangle.y;
+      case 1 /* R */:
+        return rectangle.x + rectangle.width;
+      case 2 /* B */:
+        return rectangle.y + rectangle.height;
+      case 3 /* L */:
+        return rectangle.x;
+      default:
+        return Unhandled(axisValue);
+    }
+  };
+  Rect2.corner = (rectangle, cornerValue) => {
+    switch (cornerValue) {
+      case 0 /* TL */:
+        return { x: rectangle.x, y: rectangle.y };
+      case 1 /* TR */:
+        return { x: rectangle.x + rectangle.width, y: rectangle.y };
+      case 2 /* BR */:
+        return {
+          x: rectangle.x + rectangle.width,
+          y: rectangle.y + rectangle.height
+        };
+      case 3 /* BL */:
+        return { x: rectangle.x, y: rectangle.y + rectangle.height };
+      default:
+        return Unhandled(cornerValue);
+    }
+  };
+  Rect2.center = (rectangle) => ({
+    x: rectangle.x + rectangle.width * 0.5,
+    y: rectangle.y + rectangle.height * 0.5
+  });
+  Rect2.isEmpty = (rectangle) => rectangle.width === 0 || rectangle.height === 0;
+  Rect2.union = (a, b) => {
+    if (Rect2.isEmpty(a)) {
+      if (!Rect2.isEmpty(b)) {
+        a.x = b.x;
+        a.y = b.y;
+        a.width = b.width;
+        a.height = b.height;
+      }
+    } else if (!Rect2.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;
+    }
+  };
+})(Rect || (Rect = {}));
+var AABB;
+((AABB2) => {
+  AABB2.width = (aabb) => aabb.xMax - aabb.xMin;
+  AABB2.height = (aabb) => aabb.yMax - aabb.yMin;
+  AABB2.from = (aabb, that) => {
+    aabb.xMin = that.xMin;
+    aabb.xMax = that.xMax;
+    aabb.yMin = that.yMin;
+    aabb.yMax = that.yMax;
+  };
+  AABB2.extend = (aabb, offset) => {
+    aabb.xMin -= offset;
+    aabb.yMin -= offset;
+    aabb.xMax += offset;
+    aabb.yMax += offset;
+  };
+  AABB2.padding = (aabb, [top, right, bottom, left]) => {
+    aabb.xMin += left;
+    aabb.yMin += top;
+    aabb.xMax -= right;
+    aabb.yMax -= bottom;
+    return aabb;
+  };
+  AABB2.intersectPoint = (aabb, point) => aabb.xMin <= point.x && point.x < aabb.xMax && aabb.yMin <= point.y && point.y < aabb.yMax;
+  AABB2.intersectThat = (aabb, that) => that.xMin < aabb.xMax && that.xMax > aabb.xMin && that.yMin < aabb.yMax && that.yMax > aabb.yMin;
+  AABB2.center = (aabb) => ({
+    x: (aabb.xMin + aabb.xMax) * 0.5,
+    y: (aabb.yMin + aabb.yMax) * 0.5
+  });
+})(AABB || (AABB = {}));
+var Padding;
+((Padding2) => {
+  Padding2.Identity = Object.freeze([
+    0,
+    0,
+    0,
+    0
+  ]);
+})(Padding || (Padding = {}));
+var CohenSutherland;
+((CohenSutherland2) => {
+  CohenSutherland2.intersects = (xMin, xMax, yMin, yMax, x0, y0, x1, y1) => {
+    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, xMax, yMin, yMax, x, y) => {
+    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, y0, x1, y1, x2, y2) => (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0) >= 0;
+})(CohenSutherland || (CohenSutherland = {}));
+var ValueAxis;
+((ValueAxis2) => {
+  ValueAxis2.Identity = {
+    valueToAxis: (value) => value,
+    axisToValue: (axis) => axis
+  };
+  ValueAxis2.toClamped = (valueAxis, min, max) => ({
+    valueToAxis: (value) => valueAxis.valueToAxis(clamp(value, min, max)),
+    axisToValue: (axis) => clamp(valueAxis.axisToValue(axis), min, max)
+  });
+  ValueAxis2.createClamped = (min, max) => ({
+    valueToAxis: (value) => clamp(value, min, max),
+    axisToValue: (axis) => clamp(axis, min, max)
+  });
+})(ValueAxis || (ValueAxis = {}));
+export {
+  AABB,
+  Axis,
+  CohenSutherland,
+  Corner,
+  EmptyExec,
+  EmptyProcedure,
+  Geom,
+  INVERSE_SQRT_2,
+  PI_HALF,
+  PI_QUART,
+  Padding,
+  Point,
+  Rect,
+  TAU,
+  Unhandled,
+  ValueAxis,
+  asDefined,
+  assertType,
+  clamp,
+  clampUnit,
+  cosine,
+  degToRad,
+  exponential,
+  fract,
+  getOrProvide,
+  isDefined,
+  isNotUndefined,
+  isUndefined,
+  linear,
+  mod,
+  nextPowOf2,
+  panic,
+  quantizeCeil,
+  quantizeFloor,
+  quantizeRound,
+  radToDeg,
+  squashUnit
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math.ts","../src/std.ts","../src/geom.ts"],"sourcesContent":["import type { int, unitValue } from \"./std\";\n\nexport const TAU = Math.PI * 2.0;\nexport const PI_HALF = Math.PI / 2.0;\nexport const PI_QUART = Math.PI / 4.0;\nexport const INVERSE_SQRT_2 = 1.0 / Math.sqrt(2.0);\n\nexport const clamp = (value: number, min: number, max: number): number =>\n  Math.max(min, Math.min(value, max));\nexport const clampUnit = (value: number): unitValue =>\n  Math.max(0.0, Math.min(value, 1.0));\nexport const squashUnit = (value: unitValue, margin: unitValue): unitValue =>\n  margin + (1.0 - 2.0 * margin) * Math.max(0.0, Math.min(value, 1.0));\nexport const quantizeFloor = (value: number, interval: number): number =>\n  Math.floor(value / interval) * interval;\nexport const quantizeCeil = (value: number, interval: number): number =>\n  Math.ceil(value / interval) * interval;\nexport const quantizeRound = (value: number, interval: number): number =>\n  Math.round(value / interval) * interval;\nexport const linear = (y1: number, y2: number, mu: number): number =>\n  y1 + (y2 - y1) * mu;\nexport const exponential = (y1: number, y2: number, mu: number): number =>\n  y1 * (y2 / y1) ** mu;\nexport const cosine = (y1: number, y2: number, mu: number): number => {\n  const mu2 = (1.0 - Math.cos(mu * Math.PI)) * 0.5;\n  return y1 * (1.0 - mu2) + y2 * mu2;\n};\nexport const mod = (value: number, range: number): number =>\n  fract(value / range) * range;\nexport const fract = (value: number): number => value - Math.floor(value);\nexport const nextPowOf2 = (n: int): int =>\n  2 ** Math.ceil(Math.log(n) / Math.log(2));\nexport const radToDeg = (rad: number): number => (rad * 180.0) / Math.PI;\nexport const degToRad = (deg: number): number => (deg / 180.0) * Math.PI;\n","export type int = number;\nexport type unitValue = number; // 0...1\nexport type Optional<T> = T | undefined;\nexport type Nullable<T> = T | null;\nexport type Maybe<T> = T | undefined | null;\nexport type ValueOrProvider<T> = T | (() => T);\nexport type Procedure<T> = (value: T) => void;\nexport type Func<U, T> = (value: U) => T;\nexport type AnyFunc = (...args: any[]) => any;\nexport type AssertType<T> = (value: unknown) => value is T;\nexport type Exec = () => void;\n\nexport const isDefined = <T>(value: Maybe<T>): value is T =>\n  value !== undefined && value !== null;\n\nexport const isUndefined = (value: unknown): value is undefined =>\n  value === undefined;\n\nexport const isNotUndefined = <T>(value: Optional<T>): value is T =>\n  value !== undefined;\n\nexport const asDefined = <T>(\n  value: Maybe<T>,\n  fail: ValueOrProvider<string> = \"asDefined failed\"\n): T =>\n  value === null || value === undefined ? panic(getOrProvide(fail)) : value;\n\nexport const Unhandled = <R>(empty: never): R => {\n  throw new Error(`Unhandled ${empty}`);\n};\n\nexport const panic = (issue?: string | Error | unknown): never => {\n  throw typeof issue === \"string\" ? new Error(issue) : issue;\n};\n\nexport const getOrProvide = <T>(value: ValueOrProvider<T>): T =>\n  value instanceof Function ? value() : value;\n\nexport const EmptyExec: Exec = (): void => {\n  // no-op\n};\n\nexport const EmptyProcedure: Procedure<any> = (_: any): void => {\n  // no-op\n};\n\nexport function assertType<T>(_value: unknown): asserts _value is T {\n  // no-op\n}\n","import { clamp } from \"./math\";\nimport { type int, Unhandled } from \"./std\";\n\nexport type Point = { x: number; y: number };\nexport type Circle = Point & { r: number };\nexport type Size = { width: number; height: number };\nexport type Rect = Point & Size;\nexport type Padding = [number, number, number, number];\nexport type Client = { clientX: number; clientY: number };\n\nexport enum Axis {\n  T = 0,\n  R = 1,\n  B = 2,\n  L = 3,\n}\n\nexport enum Corner {\n  TL = 0,\n  TR = 1,\n  BR = 2,\n  BL = 3,\n}\n\nexport namespace Geom {\n  export const outerTangentPoints = (a: Circle, b: Circle): [Point, Point] => {\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    const angle =\n      Math.atan2(dy, dx) +\n      Math.acos((a.r - b.r) / Math.sqrt(dx * dx + dy * dy));\n    const cs = Math.cos(angle);\n    const sn = Math.sin(angle);\n    return [\n      { x: a.x + a.r * cs, y: a.y + a.r * sn },\n      { x: b.x + b.r * cs, y: b.y + b.r * sn },\n    ];\n  };\n}\n\nexport namespace Point {\n  export const zero = (): Point => ({ x: 0, y: 0 });\n  export const create = (x: number, y: number): Point => ({ x, y });\n  export const clone = (point: Point): Point => ({ ...point });\n  export const floor = (point: Point): Point => ({\n    x: Math.floor(point.x),\n    y: Math.floor(point.y),\n  });\n  export const length = (point: Point): number =>\n    Math.sqrt(point.x * point.x + point.y * point.y);\n  export const distance = (a: Point, b: Point): number =>\n    Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);\n  export const add = (a: Point, b: Point): Point => ({\n    x: a.x + b.x,\n    y: a.y + b.y,\n  });\n  export const subtract = (a: Point, b: Point): Point => ({\n    x: a.x - b.x,\n    y: a.y - b.y,\n  });\n  export const scaleBy = (point: Point, scale: number): Point => ({\n    x: point.x * scale,\n    y: point.y * scale,\n  });\n  export const scaleTo = (point: Point, scale: number): Point => {\n    const multiplier = scale / length(point);\n    return { x: point.x * multiplier, y: point.y * multiplier };\n  };\n  export const fromClient = (object: {\n    clientX: number;\n    clientY: number;\n  }): Point => ({\n    x: object.clientX,\n    y: object.clientY,\n  });\n}\n\nexport namespace Rect {\n  export const Empty: Readonly<Rect> = Object.freeze({\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0,\n  });\n\n  export const corners = (rectangle: Rect): Array<Point> => {\n    const x0 = rectangle.x;\n    const y0 = rectangle.y;\n    const x1 = x0 + rectangle.width;\n    const y1 = y0 + rectangle.height;\n    return [\n      { x: x0, y: y0 },\n      { x: x1, y: y0 },\n      { x: x1, y: y1 },\n      { x: x0, y: y1 },\n    ];\n  };\n\n  export const inflate = (rect: Rect, amount: number): Rect => ({\n    x: rect.x - amount,\n    y: rect.y - amount,\n    width: rect.width + amount * 2.0,\n    height: rect.height + amount * 2.0,\n  });\n\n  export const contains = (outer: Rect, inner: Rect): boolean => {\n    const topLeftInside = inner.x >= outer.x && inner.y >= outer.y;\n    const bottomRightInside =\n      inner.x + inner.width <= outer.x + outer.width &&\n      inner.y + inner.height <= outer.y + outer.height;\n    return topLeftInside && bottomRightInside;\n  };\n\n  export const isPointInside = (point: Point, rect: Rect): boolean =>\n    point.x >= rect.x &&\n    point.x <= rect.x + rect.width &&\n    point.y >= rect.y &&\n    point.y <= rect.y + rect.height;\n\n  export const intersect = (a: Rect, b: Rect): boolean => {\n    const xMin = Math.max(a.x, b.x);\n    const xMax = Math.min(a.x + a.width, b.x + b.width);\n    const yMax = Math.min(a.y + a.height, b.y + b.height);\n    const yMin = Math.max(a.y, b.y);\n    return xMax > xMin && yMax > yMin;\n  };\n\n  export const axis = (rectangle: Rect, axisValue: Axis): number => {\n    switch (axisValue) {\n      case Axis.T:\n        return rectangle.y;\n      case Axis.R:\n        return rectangle.x + rectangle.width;\n      case Axis.B:\n        return rectangle.y + rectangle.height;\n      case Axis.L:\n        return rectangle.x;\n      default:\n        return Unhandled(axisValue);\n    }\n  };\n\n  export const corner = (rectangle: Rect, cornerValue: Corner): Point => {\n    switch (cornerValue) {\n      case Corner.TL:\n        return { x: rectangle.x, y: rectangle.y };\n      case Corner.TR:\n        return { x: rectangle.x + rectangle.width, y: rectangle.y };\n      case Corner.BR:\n        return {\n          x: rectangle.x + rectangle.width,\n          y: rectangle.y + rectangle.height,\n        };\n      case Corner.BL:\n        return { x: rectangle.x, y: rectangle.y + rectangle.height };\n      default:\n        return Unhandled(cornerValue);\n    }\n  };\n\n  export const center = (rectangle: Rect): Point => ({\n    x: rectangle.x + rectangle.width * 0.5,\n    y: rectangle.y + rectangle.height * 0.5,\n  });\n\n  export const isEmpty = (rectangle: Rect): boolean =>\n    rectangle.width === 0 || rectangle.height === 0;\n\n  export const union = (a: Rect, b: Readonly<Rect>): void => {\n    if (Rect.isEmpty(a)) {\n      if (!Rect.isEmpty(b)) {\n        a.x = b.x;\n        a.y = b.y;\n        a.width = b.width;\n        a.height = b.height;\n      }\n    } else if (!Rect.isEmpty(b)) {\n      const bx = b.x;\n      const by = b.y;\n      const ux = Math.min(a.x, bx);\n      const uy = Math.min(a.y, by);\n      a.width = Math.max(a.x + a.width, bx + b.width) - ux;\n      a.height = Math.max(a.y + a.height, by + b.height) - uy;\n      a.x = ux;\n      a.y = uy;\n    }\n  };\n}\n\nexport interface AABB {\n  xMin: number;\n  xMax: number;\n  yMin: number;\n  yMax: number;\n}\n\nexport namespace AABB {\n  export const width = (aabb: AABB): number => aabb.xMax - aabb.xMin;\n  export const height = (aabb: AABB): number => aabb.yMax - aabb.yMin;\n\n  export const from = (aabb: AABB, that: AABB): void => {\n    aabb.xMin = that.xMin;\n    aabb.xMax = that.xMax;\n    aabb.yMin = that.yMin;\n    aabb.yMax = that.yMax;\n  };\n\n  export const extend = (aabb: AABB, offset: number): void => {\n    aabb.xMin -= offset;\n    aabb.yMin -= offset;\n    aabb.xMax += offset;\n    aabb.yMax += offset;\n  };\n\n  export const padding = (\n    aabb: AABB,\n    [top, right, bottom, left]: Readonly<Padding>\n  ): AABB => {\n    aabb.xMin += left;\n    aabb.yMin += top;\n    aabb.xMax -= right;\n    aabb.yMax -= bottom;\n    return aabb;\n  };\n\n  export const intersectPoint = (aabb: AABB, point: Point): boolean =>\n    aabb.xMin <= point.x &&\n    point.x < aabb.xMax &&\n    aabb.yMin <= point.y &&\n    point.y < aabb.yMax;\n\n  export const intersectThat = (aabb: AABB, that: AABB): boolean =>\n    that.xMin < aabb.xMax &&\n    that.xMax > aabb.xMin &&\n    that.yMin < aabb.yMax &&\n    that.yMax > aabb.yMin;\n\n  export const center = (aabb: AABB): Point => ({\n    x: (aabb.xMin + aabb.xMax) * 0.5,\n    y: (aabb.yMin + aabb.yMax) * 0.5,\n  });\n}\n\nexport namespace Padding {\n  export const Identity: Readonly<Padding> = Object.freeze([\n    0.0, 0.0, 0.0, 0.0,\n  ]);\n}\n\nexport namespace CohenSutherland {\n  export const intersects = (\n    xMin: number,\n    xMax: number,\n    yMin: number,\n    yMax: number,\n    x0: number,\n    y0: number,\n    x1: number,\n    y1: number\n  ): boolean => {\n    const c0 = code(xMin, xMax, yMin, yMax, x0, y0);\n    const c1 = code(xMin, xMax, yMin, yMax, x1, y1);\n    if ((c0 | c1) === 0) {\n      return false;\n    }\n    if ((c0 & c1) !== 0) {\n      return false;\n    }\n    const s = sign(x0, y0, x1, y1, xMin, yMin);\n    return (\n      s !== sign(x0, y0, x1, y1, xMax, yMin) ||\n      s !== sign(x0, y0, x1, y1, xMax, yMax) ||\n      s !== sign(x0, y0, x1, y1, xMin, yMax)\n    );\n  };\n\n  const code = (\n    xMin: number,\n    xMax: number,\n    yMin: number,\n    yMax: number,\n    x: number,\n    y: number\n  ): int => {\n    let codeValue = 0;\n    if (x <= xMin) {\n      codeValue |= 1;\n    } else if (x >= xMax) {\n      codeValue |= 2;\n    }\n    if (y <= yMin) {\n      codeValue |= 8;\n    } else if (y >= yMax) {\n      codeValue |= 4;\n    }\n    return codeValue;\n  };\n\n  const sign = (\n    x0: number,\n    y0: number,\n    x1: number,\n    y1: number,\n    x2: number,\n    y2: number\n  ): boolean => (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0) >= 0;\n}\n\nexport interface ValueAxis {\n  valueToAxis(value: number): number;\n  axisToValue(axis: number): number;\n}\n\nexport namespace ValueAxis {\n  export const Identity: ValueAxis = {\n    valueToAxis: (value: number): number => value,\n    axisToValue: (axis: number): number => axis,\n  };\n\n  export const toClamped = (\n    valueAxis: ValueAxis,\n    min: number,\n    max: number\n  ): ValueAxis => ({\n    valueToAxis: (value: number): number =>\n      valueAxis.valueToAxis(clamp(value, min, max)),\n    axisToValue: (axis: number): number =>\n      clamp(valueAxis.axisToValue(axis), min, max),\n  });\n\n  export const createClamped = (min: number, max: number): ValueAxis => ({\n    valueToAxis: (value: number): number => clamp(value, min, max),\n    axisToValue: (axis: number): number => clamp(axis, min, max),\n  });\n}\n"],"mappings":"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","names":["Axis","Corner","Geom","Point","Rect","AABB","Padding","CohenSutherland","ValueAxis"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audio-ui/utils",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A collection of utility functions for Audio UI.",
   "license": "MIT",
   "module": "dist/index.js",
@@ -32,13 +32,19 @@
       "import": "./dist/dom/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build:pkg": "tsup",
-    "dev": "tsup --watch"
+    "dev": "tsup --watch",
+    "lint": "biome check --write .",
+    "lint:fix": "biome check --write --unsafe .",
+    "clean": "rm -rf dist node_modules .turbo"
   },
   "devDependencies": {
-    "@audio-ui/typescript": "workspace:*",
-    "@types/bun": "latest",
+    "@audio-ui/typescript": "latest",
+    "@types/bun": "^1.3.5",
     "tsup": "^8.5.0"
   }
 }

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

@@ -1,15 +0,0 @@
-
-$ 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

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

package/src/geom.ts

@@ -1,335 +0,0 @@
-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

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

package/src/math.ts

@@ -1,34 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

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

package/tsup.config.ts

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