curvy 1.0.8 → 2.0.0-alpha.0

package/dist/shared/rationalCubic2d-D_-XWxcm.d.mts

@@ -0,0 +1,297 @@
+import { t as Vector2 } from "./vector2-TV0UnlxY.mjs";
+import { t as Pipeable } from "./utils-DqTGyXrP.mjs";
+import { r as CubicCurve2d, t as RationalCubicCurve2d } from "./rationalCubic2d-BPLohNuI.mjs";
+
+//#region src/path/traits.d.ts
+/**
+ * Trait brands for paths.
+ *
+ * Brands are phantom types — they exist only at the type level and carry no
+ * runtime data. Refiners (`isContinuous`) and assertions (`asContinuous`) on
+ * each path module attach these brands to the path's `Trait` parameter at the
+ * type level.
+ *
+ * @since 2.0.0
+ */
+declare const ContinuousId: unique symbol;
+/**
+ * Brand for paths whose adjacent curves connect at their join points (G⁰
+ * continuity). Calling `toPathData` on a `Continuous` path skips the
+ * per-segment discontinuity check and emits a single `M` followed by drawing
+ * commands.
+ *
+ * @since 2.0.0
+ */
+type Continuous = {
+  readonly [ContinuousId]: 'continuous';
+};
+/**
+ * Phantom property key used by path interfaces to hold their `Trait` type
+ * parameter. The runtime object never has a value at this key.
+ *
+ * @since 2.0.0
+ */
+declare const PathTraits: unique symbol;
+type PathTraits = typeof PathTraits;
+//#endregion
+//#region src/path/cubic2d.internal.d.ts
+declare const CubicPath2dTypeId: unique symbol;
+type CubicPath2dTypeId = typeof CubicPath2dTypeId;
+declare namespace cubic2d_d_exports {
+  export { Continuous, CubicPath2d, append$1 as append, asContinuous, fromArray$1 as fromArray, isContinuous, isCubicPath2d, length, make$1 as make, solve$1 as solve, solveByDistance, toPathData };
+}
+/**
+ * A cubic path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Trait` type parameter accumulates trait brands as the path is refined
+ * via `isContinuous` / `asContinuous`.
+ *
+ * @since 1.0.0
+ */
+interface CubicPath2d<out Trait = unknown> extends Pipeable, Iterable<CubicCurve2d> {
+  readonly [CubicPath2dTypeId]: CubicPath2dTypeId;
+  readonly [PathTraits]: Trait;
+}
+/**
+ * Creates a new `CubicPath2d` instance from a sequence of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 2.0.0
+ */
+declare const make$1: (...curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Creates a new `CubicPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 2.0.0
+ */
+declare const fromArray$1: (curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Checks if a value is a `CubicPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `CubicPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isCubicPath2d: (p: unknown) => p is CubicPath2d;
+declare const append$1: {
+  /**
+   * Appends a cubic curve to a cubic path.
+   *
+   * @param c - The cubic curve to append.
+   * @returns A function that takes a cubic path and returns a new cubic path.
+   * @since 1.0.0
+   */
+  (c: CubicCurve2d): (p: CubicPath2d) => CubicPath2d;
+  /**
+   * Appends a cubic curve to a cubic path.
+   *
+   * @param p - The cubic path to append to.
+   * @param c - The cubic curve to append.
+   * @returns A new cubic path.
+   * @since 1.0.0
+   */
+  (p: CubicPath2d, c: CubicCurve2d): CubicPath2d;
+};
+/**
+ * Calculates the length of a cubic path.
+ *
+ * @param p - The cubic path to calculate the length of.
+ * @returns The length of the cubic path.
+ * @since 1.0.0
+ */
+declare const length: (p: CubicPath2d) => number;
+declare const solve$1: {
+  /**
+   * Solves a cubic path for a given parameter.
+   *
+   * @param u - The parameter to solve for.
+   * @returns A function that takes a cubic path and returns the solved vector.
+   * @since 1.0.0
+   */
+  (u: number): (p: CubicPath2d) => Vector2;
+  /**
+   * Solves a cubic path for a given parameter.
+   *
+   * @param p - The cubic path to solve.
+   * @param u - The parameter to solve for.
+   * @returns The solved vector.
+   * @since 1.0.0
+   */
+  (p: CubicPath2d, u: number): Vector2;
+};
+/**
+ * Serializes a cubic path as an SVG path data string (the value of a `<path>`
+ * element's `d` attribute), using `M` and `C` commands. Discontinuities between
+ * curves emit a fresh `M` command.
+ *
+ * @param p - The cubic path to serialize.
+ * @returns The SVG path data string.
+ * @since 2.0.0
+ */
+declare const toPathData: (p: CubicPath2d) => string;
+/**
+ * Type-narrowing predicate: refines `CubicPath2d<T>` to
+ * `CubicPath2d<T & Continuous>` when adjacent curves connect.
+ *
+ * @since 2.0.0
+ */
+declare const isContinuous: <T>(p: CubicPath2d<T>) => p is CubicPath2d<T & Continuous>;
+/**
+ * Asserts that the cubic path is continuous, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asContinuous: <T>(p: CubicPath2d<T>) => CubicPath2d<T & Continuous>;
+declare const solveByDistance: {
+  /**
+   * Solves a cubic path by normalized arc length. Unlike {@link solve}, which
+   * is parameterized by curve `u`, this samples points at constant speed along
+   * the path — `s = 0.5` returns the point exactly halfway along the curve by
+   * arc length, regardless of how the underlying parameterization stretches.
+   *
+   * Cumulative segment lengths are cached by path identity so repeated calls
+   * with the same path are fast.
+   *
+   * @param p - The cubic path to sample.
+   * @param s - Normalized arc length in `[0, 1]`. Values outside the range are
+   *   clamped to path endpoints.
+   * @returns The point on the path at the given normalized arc length.
+   * @since 1.1.0
+   */
+  (p: CubicPath2d, s: number): Vector2;
+  /**
+   * Solves a cubic path by normalized arc length.
+   *
+   * @param s - Normalized arc length in `[0, 1]`.
+   * @returns A function that takes a cubic path and returns the point at that
+   *   arc length.
+   * @since 1.1.0
+   */
+  (s: number): (p: CubicPath2d) => Vector2;
+};
+//#endregion
+//#region src/path/rationalCubic2d.internal.d.ts
+declare const RationalCubicPath2dTypeId: unique symbol;
+type RationalCubicPath2dTypeId = typeof RationalCubicPath2dTypeId;
+declare namespace rationalCubic2d_d_exports {
+  export { RationalCubicPath2d, append, approximateAsCubicPath, fromArray, isRationalCubicPath2d, make, solve };
+}
+/**
+ * A rational cubic path in 2D space.
+ *
+ * Holds a non-empty sequence of `RationalCubicCurve2d` segments; iteration
+ * yields the segments in order. The path parameter `u ∈ [0, 1]` is mapped
+ * uniformly across segments — `u = 0` is the start of the first segment,
+ * `u = 1` is the end of the last segment, and intermediate values pick a
+ * segment by index and a local parameter within it.
+ *
+ * Counterpart to `CubicPath2d` for curves whose evaluation includes the
+ * homogeneous-to-plane projection.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.1.0
+ */
+interface RationalCubicPath2d extends Pipeable, Iterable<RationalCubicCurve2d> {
+  readonly [RationalCubicPath2dTypeId]: RationalCubicPath2dTypeId;
+}
+/**
+ * Checks if a value is a `RationalCubicPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `RationalCubicPath2d`, `false` otherwise.
+ * @since 2.1.0
+ */
+declare const isRationalCubicPath2d: (p: unknown) => p is RationalCubicPath2d;
+/**
+ * Creates a new `RationalCubicPath2d` from a sequence of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `RationalCubicPath2d` instance.
+ * @since 2.1.0
+ */
+declare const make: (...curves: ReadonlyArray<RationalCubicCurve2d>) => RationalCubicPath2d;
+/**
+ * Creates a new `RationalCubicPath2d` from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `RationalCubicPath2d` instance.
+ * @since 2.1.0
+ */
+declare const fromArray: (curves: ReadonlyArray<RationalCubicCurve2d>) => RationalCubicPath2d;
+declare const append: {
+  /**
+   * Appends a curve to a `RationalCubicPath2d`.
+   *
+   * @param c - The curve to append.
+   * @returns A function that takes a path and returns a new path with the appended curve.
+   * @since 2.1.0
+   */
+  (c: RationalCubicCurve2d): (p: RationalCubicPath2d) => RationalCubicPath2d;
+  /**
+   * Appends a curve to a `RationalCubicPath2d`.
+   *
+   * @param p - The path to append to.
+   * @param c - The curve to append.
+   * @returns A new path with the appended curve.
+   * @since 2.1.0
+   */
+  (p: RationalCubicPath2d, c: RationalCubicCurve2d): RationalCubicPath2d;
+};
+declare const solve: {
+  /**
+   * Evaluates the rational cubic path at parameter `u ∈ [0, 1]`.
+   *
+   * Picks the segment containing `u` (uniform mapping across segments) and
+   * delegates to `RationalCubicCurve2d.solve` on that segment with the local
+   * parameter.
+   *
+   * @param p - The path to evaluate.
+   * @param u - The path parameter in `[0, 1]`.
+   * @returns The point on the path at parameter `u`.
+   * @since 2.1.0
+   */
+  (p: RationalCubicPath2d, u: number): Vector2;
+  /**
+   * Evaluates the rational cubic path at parameter `u ∈ [0, 1]`.
+   *
+   * @param u - The path parameter in `[0, 1]`.
+   * @returns A function that takes a path and returns the point at `u`.
+   * @since 2.1.0
+   */
+  (u: number): (p: RationalCubicPath2d) => Vector2;
+};
+declare const approximateAsCubicPath: {
+  /**
+   * Approximates the rational cubic path as a `CubicPath2d` via per-segment
+   * recursive subdivision. Each input segment is split until its midpoint
+   * deviates from a polynomial-cubic candidate by at most `tolerance`; the
+   * surviving candidates are concatenated into a new path.
+   *
+   * Lossy in general — only exact when every input segment has uniform
+   * weights, in which case segment count is preserved. Tighter tolerance
+   * produces more segments.
+   *
+   * @param p - The rational cubic path to approximate.
+   * @param tolerance - Maximum allowed midpoint deviation per segment; must be positive.
+   * @returns A new `CubicPath2d` approximating the input.
+   * @since 2.1.0
+   */
+  (p: RationalCubicPath2d, tolerance: number): CubicPath2d;
+  /**
+   * Approximates the rational cubic path as a `CubicPath2d`.
+   *
+   * @param tolerance - Maximum allowed midpoint deviation per segment; must be positive.
+   * @returns A function that takes a rational path and returns its approximation.
+   * @since 2.1.0
+   */
+  (tolerance: number): (p: RationalCubicPath2d) => CubicPath2d;
+};
+//#endregion
+export { Continuous as a, cubic2d_d_exports as i, rationalCubic2d_d_exports as n, PathTraits as o, CubicPath2d as r, RationalCubicPath2d as t };
+//# sourceMappingURL=rationalCubic2d-D_-XWxcm.d.mts.map

package/dist/shared/solution-BjoW7ov4.d.mts

@@ -0,0 +1,251 @@
+import { t as Pipeable } from "./utils-DqTGyXrP.mjs";
+import { t as Interval } from "./interval-hQDiKqj0.mjs";
+
+//#region src/solution/solution.d.ts
+declare namespace solution_d_exports {
+  export { AtMostOne, AtMostThree, AtMostTwo, None, One, Solution, Some, Three, Two, clip, filter, fromArray, isNone, isSome, last, map, match, max, min, none, one, three, two, unsafeLast, unsafeMax, unsafeMin, valueOrUndefined };
+}
+/**
+ * A `Solution<T>` represents the result of an operation that may produce
+ * between zero and three values of `T`. It generalizes the zoo of "0 or 1",
+ * "0 to 2", "0 to 3" return shapes used throughout curvy under one type, and
+ * provides a small namespace of operations (`value`, `last`, `min`, `max`,
+ * `filter`, `map`, `match`, …) for working with the result.
+ *
+ * Each variant carries a `_tag` discriminator and a `length` field, is
+ * iterable via `Symbol.iterator` (so existing `for..of` and spread patterns
+ * keep working), and is `Pipeable` (so a `Solution` value can be the head of
+ * a `pipe` chain).
+ *
+ * Variant-specific accessors:
+ * - `One<T>`, `Two<T>`, and `Three<T>` all expose `.value: T` (the first /
+ *   primary value).
+ * - `Two<T>` and `Three<T>` additionally expose `.values: readonly [T, ...]`
+ *   for explicit positional access.
+ *
+ * Operations that return narrower cardinalities (e.g. inverse-solving a
+ * monotonic polynomial) use the `AtMost{One,Two,Three}` aliases to express
+ * "this could be empty, but it'll have at most N values."
+ *
+ * @since 2.0.0
+ */
+type Solution<T> = None | One<T> | Two<T> | Three<T>;
+/**
+ * The empty solution.
+ *
+ * @since 2.0.0
+ */
+interface None extends Pipeable, Iterable<never> {
+  readonly _tag: 'none';
+  readonly length: 0;
+}
+/** @since 2.0.0 */
+interface One<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'one';
+  readonly length: 1;
+  readonly value: T;
+}
+/** @since 2.0.0 */
+interface Two<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'two';
+  readonly length: 2;
+  readonly value: T;
+  readonly values: readonly [T, T];
+}
+/** @since 2.0.0 */
+interface Three<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'three';
+  readonly length: 3;
+  readonly value: T;
+  readonly values: readonly [T, T, T];
+}
+/**
+ * Any non-empty solution. All `Some<T>` values expose `.value: T` directly —
+ * no narrowing required to read the primary value.
+ *
+ * @since 2.0.0
+ */
+type Some<T> = One<T> | Two<T> | Three<T>;
+/**
+ * `None | One<T>` — return type of operations that produce at most one value
+ * (e.g. inverse-solving a strictly monotonic polynomial).
+ *
+ * @since 2.0.0
+ */
+type AtMostOne<T> = None | One<T>;
+/**
+ * `None | One<T> | Two<T>` — return type of operations that produce at most
+ * two values (e.g. inverse-solving an unrestricted quadratic polynomial).
+ *
+ * @since 2.0.0
+ */
+type AtMostTwo<T> = None | One<T> | Two<T>;
+/**
+ * `None | One<T> | Two<T> | Three<T>` — equivalent to `Solution<T>`.
+ *
+ * @since 2.0.0
+ */
+type AtMostThree<T> = Solution<T>;
+/**
+ * The empty solution. Reused across calls — never reallocated.
+ *
+ * @since 2.0.0
+ */
+declare const none: None;
+/**
+ * Constructs a single-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const one: <T>(value: T) => One<T>;
+/**
+ * Constructs a two-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const two: <T>(a: T, b: T) => Two<T>;
+/**
+ * Constructs a three-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const three: <T>(a: T, b: T, c: T) => Three<T>;
+/**
+ * Constructs a `Solution<T>` from a runtime array. Throws if the array has
+ * more than three elements.
+ *
+ * @since 2.0.0
+ */
+declare const fromArray: <T>(arr: ReadonlyArray<T>) => Solution<T>;
+/**
+ * Type-narrowing predicate: refines `Solution<T>` to `None`.
+ *
+ * @since 2.0.0
+ */
+declare const isNone: <T>(s: Solution<T>) => s is None;
+/**
+ * Type-narrowing predicate: refines `Solution<T>` to `Some<T>` (non-empty).
+ * After narrowing, `.value` is directly accessible without further checks.
+ *
+ * @since 2.0.0
+ */
+declare const isSome: <T>(s: Solution<T>) => s is Some<T>;
+/**
+ * Returns the primary (first) value if the solution is non-empty, or
+ * `undefined` if empty. Pair with `.value` access on `Some<T>`-narrowed
+ * inputs to avoid the `undefined` possibility.
+ *
+ * @since 2.0.0
+ */
+declare const valueOrUndefined: <T>(s: Solution<T>) => T | undefined;
+/**
+ * Returns the last value in the solution, or `undefined` if empty. When
+ * called on a `Some<T>`, the result is guaranteed to be `T`.
+ *
+ * @since 2.0.0
+ */
+declare const last: {
+  <T>(s: Some<T>): T;
+  <T>(s: Solution<T>): T | undefined;
+};
+/**
+ * Returns the smallest numeric value in the solution, or `undefined` if empty.
+ * When called on a `Some<number>`, the result is guaranteed to be `number`.
+ *
+ * @since 2.0.0
+ */
+declare const min: {
+  (s: Some<number>): number;
+  (s: Solution<number>): number | undefined;
+};
+/**
+ * Returns the largest numeric value in the solution, or `undefined` if empty.
+ * When called on a `Some<number>`, the result is guaranteed to be `number`.
+ *
+ * @since 2.0.0
+ */
+declare const max: {
+  (s: Some<number>): number;
+  (s: Solution<number>): number | undefined;
+};
+/**
+ * Returns the last value in the solution. Throws if empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeLast: <T>(s: Solution<T>) => T;
+/**
+ * Returns the smallest numeric value in the solution. Throws on empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeMin: (s: Solution<number>) => number;
+/**
+ * Returns the largest numeric value in the solution. Throws on empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeMax: (s: Solution<number>) => number;
+/**
+ * Filters the solution by a predicate. Result cardinality is at most that of
+ * the input.
+ *
+ * @since 2.0.0
+ */
+declare const filter: <T>(s: Solution<T>, predicate: (v: T) => boolean) => Solution<T>;
+/**
+ * Restricts the solution to values contained within an interval. Endpoint
+ * inclusivity follows the interval's `kind` — pass an open variant (e.g.
+ * `Interval.makeOpen(0, 1)` or `Interval.unitOpen`) for strict containment.
+ *
+ * @param s - The solution to clip.
+ * @param i - The interval to retain values within.
+ * @since 2.0.0
+ */
+declare const clip: {
+  (i: Interval): (s: Solution<number>) => Solution<number>;
+  (s: Solution<number>, i: Interval): Solution<number>;
+};
+/**
+ * Maps every value in the solution to a new value. Result cardinality matches
+ * the input.
+ *
+ * @since 2.0.0
+ */
+declare const map: {
+  <A, B>(s: Solution<A>, f: (v: A) => B): Solution<B>;
+  <A, B>(f: (v: A) => B): (s: Solution<A>) => Solution<B>;
+};
+type SomeOf<S> = S extends None ? never : S;
+/**
+ * Pattern matches on a solution, calling `onNone` for the empty case and
+ * `onSome` for any non-empty case. The `onSome` parameter is typed against
+ * the input's narrowed shape — for an `AtMostOne<T>` input, `onSome` receives
+ * `One<T>` and can read `.value` directly.
+ *
+ * @example
+ * ```ts
+ * const result = polynomial.pipe(
+ *   LinearPolynomial.solveInverse(0),
+ *   Solution.match({
+ *     onNone: () => null,
+ *     onSome: ({ value }) => Math.abs(value),
+ *   }),
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ */
+declare const match: {
+  <S extends Solution<unknown>, A, B>(self: S, matcher: {
+    readonly onNone: () => A;
+    readonly onSome: (s: SomeOf<S>) => B;
+  }): A | B;
+  <S extends Solution<unknown>, A, B>(matcher: {
+    readonly onNone: () => A;
+    readonly onSome: (s: SomeOf<S>) => B;
+  }): (self: S) => A | B;
+};
+//#endregion
+export { solution_d_exports as a, One as i, AtMostThree as n, AtMostTwo as r, AtMostOne as t };
+//# sourceMappingURL=solution-BjoW7ov4.d.mts.map