@twick/core 0.11.0

package/lib/types/Vector.js

@@ -0,0 +1,355 @@
+import { CompoundSignalContext } from '../signals';
+import { arcLerp, clamp, map } from '../tweening';
+import { DEG2RAD, RAD2DEG } from '../utils';
+import { Direction, Origin } from './alignment-enums';
+import { EPSILON } from './Type';
+/**
+ * Represents a two-dimensional vector.
+ */
+export class Vector2 {
+    static createSignal(initial, interpolation = Vector2.lerp, owner) {
+        return new CompoundSignalContext(['x', 'y'], (value) => new Vector2(value), initial, interpolation, owner).toSignal();
+    }
+    static lerp(from, to, value) {
+        let valueX;
+        let valueY;
+        if (typeof value === 'number') {
+            valueX = valueY = value;
+        }
+        else {
+            valueX = value.x;
+            valueY = value.y;
+        }
+        return new Vector2(map(from.x, to.x, valueX), map(from.y, to.y, valueY));
+    }
+    static arcLerp(from, to, value, reverse = false, ratio) {
+        ratio ?? (ratio = from.sub(to).ctg);
+        return Vector2.lerp(from, to, new Vector2(arcLerp(value, reverse, ratio)));
+    }
+    static createArcLerp(reverse, ratio) {
+        return (from, to, value) => Vector2.arcLerp(from, to, value, reverse, ratio);
+    }
+    /**
+     * Interpolates between two vectors on the polar plane by interpolating
+     * the angles and magnitudes of the vectors individually.
+     *
+     * @param from - The starting vector.
+     * @param to - The target vector.
+     * @param value - The t-value of the interpolation.
+     * @param counterclockwise - Whether the vector should get rotated
+     *                           counterclockwise. Defaults to `false`.
+     * @param origin - The center of rotation. Defaults to the origin.
+     *
+     * @remarks
+     * This function is useful when used in conjunction with {@link rotate} to
+     * animate an object's position on a circular arc (see examples).
+     *
+     * @example
+     * Animating an object in a circle around the origin
+     * ```tsx
+     * circle().position(
+     *   circle().position().rotate(180),
+     *   1,
+     *   easeInOutCubic,
+     *   Vector2.polarLerp
+     * );
+     * ```
+     * @example
+     * Rotating an object around the point `[-200, 100]`
+     * ```ts
+     * circle().position(
+     *   circle().position().rotate(180, [-200, 100]),
+     *   1,
+     *   easeInOutCubic,
+     *   Vector2.createPolarLerp(false, [-200, 100]),
+     * );
+     * ```
+     * @example
+     * Rotating an object counterclockwise around the origin
+     * ```ts
+     * circle().position(
+     *   circle().position().rotate(180),
+     *   1,
+     *   easeInOutCubic,
+     *   Vector2.createPolarLerp(true),
+     * );
+     * ```
+     */
+    static polarLerp(from, to, value, counterclockwise = false, origin = Vector2.zero) {
+        from = from.sub(origin);
+        to = to.sub(origin);
+        const fromAngle = from.degrees;
+        let toAngle = to.degrees;
+        const isCounterclockwise = fromAngle > toAngle;
+        if (isCounterclockwise !== counterclockwise) {
+            toAngle = toAngle + (counterclockwise ? -360 : 360);
+        }
+        const angle = map(fromAngle, toAngle, value) * DEG2RAD;
+        const magnitude = map(from.magnitude, to.magnitude, value);
+        return new Vector2(magnitude * Math.cos(angle) + origin.x, magnitude * Math.sin(angle) + origin.y);
+    }
+    /**
+     * Helper function to create a {@link Vector2.polarLerp} interpolation
+     * function with additional parameters.
+     *
+     * @param counterclockwise - Whether the point should get rotated
+     *                           counterclockwise.
+     * @param center - The center of rotation. Defaults to the origin.
+     */
+    static createPolarLerp(counterclockwise = false, center = Vector2.zero) {
+        return (from, to, value) => Vector2.polarLerp(from, to, value, counterclockwise, new Vector2(center));
+    }
+    static fromOrigin(origin) {
+        const position = new Vector2();
+        if (origin === Origin.Middle) {
+            return position;
+        }
+        if (origin & Direction.Left) {
+            position.x = -1;
+        }
+        else if (origin & Direction.Right) {
+            position.x = 1;
+        }
+        if (origin & Direction.Top) {
+            position.y = -1;
+        }
+        else if (origin & Direction.Bottom) {
+            position.y = 1;
+        }
+        return position;
+    }
+    static fromScalar(value) {
+        return new Vector2(value, value);
+    }
+    static fromRadians(radians) {
+        return new Vector2(Math.cos(radians), Math.sin(radians));
+    }
+    static fromDegrees(degrees) {
+        return Vector2.fromRadians(degrees * DEG2RAD);
+    }
+    /**
+     * Return the angle in radians between the vector described by x and y and the
+     * positive x-axis.
+     *
+     * @param x - The x component of the vector.
+     * @param y - The y component of the vector.
+     */
+    static radians(x, y) {
+        return Math.atan2(y, x);
+    }
+    /**
+     * Return the angle in degrees between the vector described by x and y and the
+     * positive x-axis.
+     *
+     * @param x - The x component of the vector.
+     * @param y - The y component of the vector.
+     *
+     * @remarks
+     * The returned angle will be between -180 and 180 degrees.
+     */
+    static degrees(x, y) {
+        return Vector2.radians(x, y) * RAD2DEG;
+    }
+    static magnitude(x, y) {
+        return Math.sqrt(x * x + y * y);
+    }
+    static squaredMagnitude(x, y) {
+        return x * x + y * y;
+    }
+    static angleBetween(u, v) {
+        return (Math.acos(clamp(-1, 1, u.dot(v) / (u.magnitude * v.magnitude))) *
+            (u.cross(v) >= 0 ? 1 : -1));
+    }
+    get width() {
+        return this.x;
+    }
+    set width(value) {
+        this.x = value;
+    }
+    get height() {
+        return this.y;
+    }
+    set height(value) {
+        this.y = value;
+    }
+    get magnitude() {
+        return Vector2.magnitude(this.x, this.y);
+    }
+    get squaredMagnitude() {
+        return Vector2.squaredMagnitude(this.x, this.y);
+    }
+    get normalized() {
+        return this.scale(1 / Vector2.magnitude(this.x, this.y));
+    }
+    get safe() {
+        return new Vector2(isNaN(this.x) ? 0 : this.x, isNaN(this.y) ? 0 : this.y);
+    }
+    get flipped() {
+        return new Vector2(-this.x, -this.y);
+    }
+    get floored() {
+        return new Vector2(Math.floor(this.x), Math.floor(this.y));
+    }
+    get perpendicular() {
+        return new Vector2(this.y, -this.x);
+    }
+    /**
+     * Return the angle in radians between the vector and the positive x-axis.
+     */
+    get radians() {
+        return Vector2.radians(this.x, this.y);
+    }
+    /**
+     * Return the angle in degrees between the vector and the positive x-axis.
+     *
+     * @remarks
+     * The returned angle will be between -180 and 180 degrees.
+     */
+    get degrees() {
+        return Vector2.degrees(this.x, this.y);
+    }
+    get ctg() {
+        return this.x / this.y;
+    }
+    constructor(one, two) {
+        this.x = 0;
+        this.y = 0;
+        if (one === undefined || one === null) {
+            return;
+        }
+        if (typeof one !== 'object') {
+            this.x = one;
+            this.y = two ?? one;
+            return;
+        }
+        if (Array.isArray(one)) {
+            this.x = one[0];
+            this.y = one[1];
+            return;
+        }
+        if ('width' in one) {
+            this.x = one.width;
+            this.y = one.height;
+            return;
+        }
+        this.x = one.x;
+        this.y = one.y;
+    }
+    lerp(to, value) {
+        return Vector2.lerp(this, to, value);
+    }
+    getOriginOffset(origin) {
+        const offset = Vector2.fromOrigin(origin);
+        offset.x *= this.x / 2;
+        offset.y *= this.y / 2;
+        return offset;
+    }
+    scale(value) {
+        return new Vector2(this.x * value, this.y * value);
+    }
+    mul(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return new Vector2(this.x * vector.x, this.y * vector.y);
+    }
+    div(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return new Vector2(this.x / vector.x, this.y / vector.y);
+    }
+    add(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return new Vector2(this.x + vector.x, this.y + vector.y);
+    }
+    sub(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return new Vector2(this.x - vector.x, this.y - vector.y);
+    }
+    dot(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return this.x * vector.x + this.y * vector.y;
+    }
+    cross(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return this.x * vector.y - this.y * vector.x;
+    }
+    mod(possibleVector) {
+        const vector = new Vector2(possibleVector);
+        return new Vector2(this.x % vector.x, this.y % vector.y);
+    }
+    addX(value) {
+        return new Vector2(this.x + value, this.y);
+    }
+    addY(value) {
+        return new Vector2(this.x, this.y + value);
+    }
+    toSymbol() {
+        return Vector2.symbol;
+    }
+    toString() {
+        return `Vector2(${this.x}, ${this.y})`;
+    }
+    toUniform(gl, location) {
+        gl.uniform2f(location, this.x, this.y);
+    }
+    serialize() {
+        return { x: this.x, y: this.y };
+    }
+    /**
+     * Check if two vectors are exactly equal to each other.
+     *
+     * @remarks
+     * If you need to compensate for floating point inaccuracies, use the
+     * {@link equals} method, instead.
+     *
+     * @param other - The vector to compare.
+     */
+    exactlyEquals(other) {
+        return this.x === other.x && this.y === other.y;
+    }
+    /**
+     * Check if two vectors are equal to each other.
+     *
+     * @remarks
+     * This method allows passing an allowed error margin when comparing vectors
+     * to compensate for floating point inaccuracies. To check if two vectors are
+     * exactly equal, use the {@link exactlyEquals} method, instead.
+     *
+     * @param other - The vector to compare.
+     * @param threshold - The allowed error threshold when comparing the vectors.
+     */
+    equals(other, threshold = EPSILON) {
+        return (Math.abs(this.x - other.x) <= threshold + Number.EPSILON &&
+            Math.abs(this.y - other.y) <= threshold + Number.EPSILON);
+    }
+}
+Vector2.symbol = Symbol.for('@twick/core/types/Vector2');
+Vector2.zero = new Vector2();
+Vector2.one = new Vector2(1, 1);
+Vector2.right = new Vector2(1, 0);
+Vector2.left = new Vector2(-1, 0);
+Vector2.up = new Vector2(0, 1);
+Vector2.down = new Vector2(0, -1);
+/**
+ * A constant equal to `Vector2(0, -1)`
+ */
+Vector2.top = new Vector2(0, -1);
+/**
+ * A constant equal to `Vector2(0, 1)`
+ */
+Vector2.bottom = new Vector2(0, 1);
+/**
+ * A constant equal to `Vector2(-1, -1)`
+ */
+Vector2.topLeft = new Vector2(-1, -1);
+/**
+ * A constant equal to `Vector2(1, -1)`
+ */
+Vector2.topRight = new Vector2(1, -1);
+/**
+ * A constant equal to `Vector2(-1, 1)`
+ */
+Vector2.bottomLeft = new Vector2(-1, 1);
+/**
+ * A constant equal to `Vector2(1, 1)`
+ */
+Vector2.bottomRight = new Vector2(1, 1);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Vector.js","sourceRoot":"","sources":["../../src/types/Vector.ts"],"names":[],"mappings":"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"}

package/lib/types/alignment-enums.d.ts

@@ -0,0 +1,22 @@
+export declare enum Direction {
+    Top = 4,
+    Bottom = 8,
+    Left = 16,
+    Right = 32
+}
+export declare enum Center {
+    Vertical = 1,
+    Horizontal = 2
+}
+export declare enum Origin {
+    Middle = 3,
+    Top = 5,
+    Bottom = 9,
+    Left = 18,
+    Right = 34,
+    TopLeft = 20,
+    TopRight = 36,
+    BottomLeft = 24,
+    BottomRight = 40
+}
+//# sourceMappingURL=alignment-enums.d.ts.map

package/lib/types/alignment-enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignment-enums.d.ts","sourceRoot":"","sources":["../../src/types/alignment-enums.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACnB,GAAG,IAAI;IACP,MAAM,IAAI;IACV,IAAI,KAAK;IACT,KAAK,KAAK;CACX;AAED,oBAAY,MAAM;IAChB,QAAQ,IAAI;IACZ,UAAU,IAAI;CACf;AAED,oBAAY,MAAM;IAChB,MAAM,IAAI;IACV,GAAG,IAAI;IACP,MAAM,IAAI;IACV,IAAI,KAAK;IACT,KAAK,KAAK;IACV,OAAO,KAAK;IACZ,QAAQ,KAAK;IACb,UAAU,KAAK;IACf,WAAW,KAAK;CACjB"}

package/lib/types/alignment-enums.js

@@ -0,0 +1,25 @@
+export var Direction;
+(function (Direction) {
+    Direction[Direction["Top"] = 4] = "Top";
+    Direction[Direction["Bottom"] = 8] = "Bottom";
+    Direction[Direction["Left"] = 16] = "Left";
+    Direction[Direction["Right"] = 32] = "Right";
+})(Direction || (Direction = {}));
+export var Center;
+(function (Center) {
+    Center[Center["Vertical"] = 1] = "Vertical";
+    Center[Center["Horizontal"] = 2] = "Horizontal";
+})(Center || (Center = {}));
+export var Origin;
+(function (Origin) {
+    Origin[Origin["Middle"] = 3] = "Middle";
+    Origin[Origin["Top"] = 5] = "Top";
+    Origin[Origin["Bottom"] = 9] = "Bottom";
+    Origin[Origin["Left"] = 18] = "Left";
+    Origin[Origin["Right"] = 34] = "Right";
+    Origin[Origin["TopLeft"] = 20] = "TopLeft";
+    Origin[Origin["TopRight"] = 36] = "TopRight";
+    Origin[Origin["BottomLeft"] = 24] = "BottomLeft";
+    Origin[Origin["BottomRight"] = 40] = "BottomRight";
+})(Origin || (Origin = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpZ25tZW50LWVudW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2FsaWdubWVudC1lbnVtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxTQUtYO0FBTEQsV0FBWSxTQUFTO0lBQ25CLHVDQUFPLENBQUE7SUFDUCw2Q0FBVSxDQUFBO0lBQ1YsMENBQVMsQ0FBQTtJQUNULDRDQUFVLENBQUE7QUFDWixDQUFDLEVBTFcsU0FBUyxLQUFULFNBQVMsUUFLcEI7QUFFRCxNQUFNLENBQU4sSUFBWSxNQUdYO0FBSEQsV0FBWSxNQUFNO0lBQ2hCLDJDQUFZLENBQUE7SUFDWiwrQ0FBYyxDQUFBO0FBQ2hCLENBQUMsRUFIVyxNQUFNLEtBQU4sTUFBTSxRQUdqQjtBQUVELE1BQU0sQ0FBTixJQUFZLE1BVVg7QUFWRCxXQUFZLE1BQU07SUFDaEIsdUNBQVUsQ0FBQTtJQUNWLGlDQUFPLENBQUE7SUFDUCx1Q0FBVSxDQUFBO0lBQ1Ysb0NBQVMsQ0FBQTtJQUNULHNDQUFVLENBQUE7SUFDViwwQ0FBWSxDQUFBO0lBQ1osNENBQWEsQ0FBQTtJQUNiLGdEQUFlLENBQUE7SUFDZixrREFBZ0IsQ0FBQTtBQUNsQixDQUFDLEVBVlcsTUFBTSxLQUFOLE1BQU0sUUFVakIifQ==

package/lib/types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Complex types used in animations.
+ *
+ * @packageDocumentation
+ */
+export * from './alignment-enums';
+export * from './BBox';
+export * from './Canvas';
+export * from './Color';
+export * from './Matrix';
+export * from './Matrix2D';
+export * from './Origin';
+export * from './Spacing';
+export * from './Type';
+export * from './Vector';
+export * from './vector-transformations';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,0BAA0B,CAAC"}

package/lib/types/index.js

@@ -0,0 +1,17 @@
+/**
+ * Complex types used in animations.
+ *
+ * @packageDocumentation
+ */
+export * from './alignment-enums';
+export * from './BBox';
+export * from './Canvas';
+export * from './Color';
+export * from './Matrix';
+export * from './Matrix2D';
+export * from './Origin';
+export * from './Spacing';
+export * from './Type';
+export * from './Vector';
+export * from './vector-transformations';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYywwQkFBMEIsQ0FBQyJ9

package/lib/types/vector-transformations.d.ts

@@ -0,0 +1,20 @@
+/**
+ * These are the functions that can be used to apply transformations to a vector.
+ *
+ * These can't be methods of the vector class because they depend on Matrix2D which
+ * would create a circular dependency.
+ */
+import type { PossibleMatrix2D } from './Matrix2D';
+import type { PossibleVector2 } from './Vector';
+import { Vector2 } from './Vector';
+export declare function transformVectorAsPoint(vector: Vector2, matrix: PossibleMatrix2D): Vector2;
+export declare function transformVector(vector: Vector2, matrix: PossibleMatrix2D): Vector2;
+/**
+ * Rotates the vector around a point by the provided angle.
+ *
+ * @param vector - The vector to rotate.
+ * @param angle - The angle by which to rotate in degrees.
+ * @param center - The center of rotation. Defaults to the origin.
+ */
+export declare function rotateVector(vector: Vector2, angle: number, center?: PossibleVector2): Vector2;
+//# sourceMappingURL=vector-transformations.d.ts.map

package/lib/types/vector-transformations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-transformations.d.ts","sourceRoot":"","sources":["../../src/types/vector-transformations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEjD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AAEjC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,gBAAgB,WAQzB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,gBAAgB,WAOxE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,eAA8B,GACrC,OAAO,CAQT"}

package/lib/types/vector-transformations.js

@@ -0,0 +1,31 @@
+/**
+ * These are the functions that can be used to apply transformations to a vector.
+ *
+ * These can't be methods of the vector class because they depend on Matrix2D which
+ * would create a circular dependency.
+ */
+import { Matrix2D } from './Matrix2D';
+import { Vector2 } from './Vector';
+export function transformVectorAsPoint(vector, matrix) {
+    const m = new Matrix2D(matrix);
+    return new Vector2(vector.x * m.scaleX + vector.y * m.skewY + m.translateX, vector.x * m.skewX + vector.y * m.scaleY + m.translateY);
+}
+export function transformVector(vector, matrix) {
+    const m = new Matrix2D(matrix);
+    return new Vector2(vector.x * m.scaleX + vector.y * m.skewY, vector.x * m.skewX + vector.y * m.scaleY);
+}
+/**
+ * Rotates the vector around a point by the provided angle.
+ *
+ * @param vector - The vector to rotate.
+ * @param angle - The angle by which to rotate in degrees.
+ * @param center - The center of rotation. Defaults to the origin.
+ */
+export function rotateVector(vector, angle, center = Vector2.zero) {
+    const originVector = new Vector2(center);
+    const matrix = Matrix2D.fromTranslation(originVector)
+        .rotate(angle)
+        .translate(originVector.flipped);
+    return transformVectorAsPoint(vector, matrix);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVjdG9yLXRyYW5zZm9ybWF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy92ZWN0b3ItdHJhbnNmb3JtYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBR0gsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLFlBQVksQ0FBQztBQUVwQyxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBRWpDLE1BQU0sVUFBVSxzQkFBc0IsQ0FDcEMsTUFBZSxFQUNmLE1BQXdCO0lBRXhCLE1BQU0sQ0FBQyxHQUFHLElBQUksUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRS9CLE9BQU8sSUFBSSxPQUFPLENBQ2hCLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFDdkQsTUFBTSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsVUFBVSxDQUN4RCxDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSxlQUFlLENBQUMsTUFBZSxFQUFFLE1BQXdCO0lBQ3ZFLE1BQU0sQ0FBQyxHQUFHLElBQUksUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRS9CLE9BQU8sSUFBSSxPQUFPLENBQ2hCLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQ3hDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssR0FBRyxNQUFNLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQ3pDLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FDMUIsTUFBZSxFQUNmLEtBQWEsRUFDYixTQUEwQixPQUFPLENBQUMsSUFBSTtJQUV0QyxNQUFNLFlBQVksR0FBRyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV6QyxNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsZUFBZSxDQUFDLFlBQVksQ0FBQztTQUNsRCxNQUFNLENBQUMsS0FBSyxDQUFDO1NBQ2IsU0FBUyxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUVuQyxPQUFPLHNCQUFzQixDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNoRCxDQUFDIn0=

package/lib/utils/DetailedError.d.ts

@@ -0,0 +1,24 @@
+import type { LogPayload } from '../app';
+type DetailedErrorProps = Pick<LogPayload, 'message' | 'remarks' | 'object' | 'durationMs' | 'inspect'>;
+export declare class DetailedError extends Error {
+    /**
+     * {@inheritDoc app.LogPayload.message}
+     */
+    readonly remarks?: string;
+    /**
+     * {@inheritDoc app.LogPayload.object}
+     */
+    readonly object?: any;
+    /**
+     * {@inheritDoc app.LogPayload.durationMs}
+     */
+    readonly durationMs?: number;
+    /**
+     * {@inheritDoc app.LogPayload.inspect}
+     */
+    readonly inspect?: string;
+    constructor(message: string, remarks?: string);
+    constructor(props: DetailedErrorProps);
+}
+export {};
+//# sourceMappingURL=DetailedError.d.ts.map

package/lib/utils/DetailedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetailedError.d.ts","sourceRoot":"","sources":["../../src/utils/DetailedError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,QAAQ,CAAC;AAEvC,KAAK,kBAAkB,GAAG,IAAI,CAC5B,UAAU,EACV,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAC5D,CAAC;AAEF,qBAAa,aAAc,SAAQ,KAAK;IACtC;;OAEG;IACH,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjC;;OAEG;IACH,SAAgB,MAAM,CAAC,EAAE,GAAG,CAAC;IAC7B;;OAEG;IACH,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpC;;OAEG;IACH,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;gBACjC,KAAK,EAAE,kBAAkB;CAa7C"}

package/lib/utils/DetailedError.js

@@ -0,0 +1,16 @@
+export class DetailedError extends Error {
+    constructor(props, remarks) {
+        if (typeof props === 'string') {
+            super(props);
+            this.remarks = remarks;
+        }
+        else {
+            super(props.message);
+            this.remarks = props.remarks;
+            this.object = props.object;
+            this.durationMs = props.durationMs;
+            this.inspect = props.inspect;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGV0YWlsZWRFcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9EZXRhaWxlZEVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE1BQU0sT0FBTyxhQUFjLFNBQVEsS0FBSztJQW9CdEMsWUFBbUIsS0FBa0MsRUFBRSxPQUFnQjtRQUNyRSxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzlCLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNiLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3pCLENBQUM7YUFBTSxDQUFDO1lBQ04sS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNyQixJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUM7WUFDN0IsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQzNCLElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDLFVBQVUsQ0FBQztZQUNuQyxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUM7UUFDL0IsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/lib/utils/ExperimentalError.d.ts

@@ -0,0 +1,10 @@
+import type { LogPayload } from '../app';
+import { DetailedError } from './DetailedError';
+export declare const experimentalFeatures = "\nThis feature requires enabling the `experimentalFeatures` flag in your project\nconfiguration:\n\n```ts\nexport default makeProject({\n  experimentalFeatures: true,\n  // ...\n});\n```\n\n[Learn more](https://motioncanvas.io/docs/experimental) about experimental\nfeatures.\n";
+type ExperimentalErrorProps = Pick<LogPayload, 'message' | 'remarks' | 'object' | 'durationMs' | 'inspect'>;
+export declare class ExperimentalError extends DetailedError {
+    constructor(message: string, remarks?: string);
+    constructor(props: ExperimentalErrorProps);
+}
+export {};
+//# sourceMappingURL=ExperimentalError.d.ts.map

package/lib/utils/ExperimentalError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExperimentalError.d.ts","sourceRoot":"","sources":["../../src/utils/ExperimentalError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C,eAAO,MAAM,oBAAoB,0RAahC,CAAC;AAEF,KAAK,sBAAsB,GAAG,IAAI,CAChC,UAAU,EACV,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAC5D,CAAC;AAEF,qBAAa,iBAAkB,SAAQ,aAAa;gBAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;gBACjC,KAAK,EAAE,sBAAsB;CAcjD"}

package/lib/utils/ExperimentalError.js

@@ -0,0 +1,32 @@
+import { DetailedError } from './DetailedError';
+export const experimentalFeatures = `
+This feature requires enabling the \`experimentalFeatures\` flag in your project
+configuration:
+
+\`\`\`ts
+export default makeProject({
+  experimentalFeatures: true,
+  // ...
+});
+\`\`\`
+
+[Learn more](https://motioncanvas.io/docs/experimental) about experimental
+features.
+`;
+export class ExperimentalError extends DetailedError {
+    constructor(props, remarks) {
+        if (typeof props === 'string') {
+            super({
+                message: props,
+                remarks: (remarks ?? '') + experimentalFeatures,
+            });
+        }
+        else {
+            super({
+                ...props,
+                remarks: (props.remarks ?? '') + experimentalFeatures,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXhwZXJpbWVudGFsRXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvRXhwZXJpbWVudGFsRXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLGFBQWEsRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBRTlDLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHOzs7Ozs7Ozs7Ozs7O0NBYW5DLENBQUM7QUFPRixNQUFNLE9BQU8saUJBQWtCLFNBQVEsYUFBYTtJQUdsRCxZQUFtQixLQUFzQyxFQUFFLE9BQWdCO1FBQ3pFLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDOUIsS0FBSyxDQUFDO2dCQUNKLE9BQU8sRUFBRSxLQUFLO2dCQUNkLE9BQU8sRUFBRSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsR0FBRyxvQkFBb0I7YUFDaEQsQ0FBQyxDQUFDO1FBQ0wsQ0FBQzthQUFNLENBQUM7WUFDTixLQUFLLENBQUM7Z0JBQ0osR0FBRyxLQUFLO2dCQUNSLE9BQU8sRUFBRSxDQUFDLEtBQUssQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDLEdBQUcsb0JBQW9CO2FBQ3RELENBQUMsQ0FBQztRQUNMLENBQUM7SUFDSCxDQUFDO0NBQ0YifQ==

package/lib/utils/Semaphore.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A simple semaphore implementation with a capacity of 1.
+ *
+ * @internal
+ */
+export declare class Semaphore {
+    private resolveCurrent;
+    private current;
+    acquire(): Promise<void>;
+    release(): void;
+}
+//# sourceMappingURL=Semaphore.d.ts.map

package/lib/utils/Semaphore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Semaphore.d.ts","sourceRoot":"","sources":["../../src/utils/Semaphore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,OAAO,CAA8B;IAEhC,OAAO;IASb,OAAO;CAKf"}