signup button added to docs, link to discord on homepage, new docs on base categories - math, vectors, points

Author: matas-bitbybit-dev

docs/docusaurus.config.ts

@@ -113,6 +113,13 @@ const config: Config = {
                     className: "navbar__button--support", // Custom class for styling
                     "aria-label": "Support the Project Mission", // For accessibility
                 },
+                {
+                    href: "https://bitbybit.dev/auth/sign-up",
+                    label: "Sign Up",
+                    position: "right",
+                    className: "navbar__button--support",
+                    "aria-label": "Sign Up to Bitbybit.dev",
+                },
                 {
                     href: "https://github.com/bitbybit-dev/bitbybit",
                     label: "GitHub",

docs/learn/code/common/base/_category_.json

@@ -0,0 +1,10 @@
+{
+    "label": "Base",
+    "position": 1,
+    "link": {
+        "type": "generated-index",
+        "title": "Base Algorithms in Bitbybit",
+        "description": "Base algorithms in Bitbybit provide foundational algorithms & object types, such as vectors, matrixes, points, lines, polylines, triangles and meshes. Learn how to use these algorithms to create complex shapes, grids and designs.",
+        "slug": "/code/common/base"
+    }
+}

docs/learn/code/common/base/intro.md

@@ -0,0 +1,5 @@
+---
+sidebar_position: 1
+title: Intro
+sidebar_label: Base Intro
+---

docs/learn/code/common/base/math/_category_.json

@@ -0,0 +1,10 @@
+{
+    "label": "Math",
+    "position": 1,
+    "link": {
+        "type": "generated-index",
+        "title": "Math Algorithms in Bitbybit",
+        "description": "Introduction to math algorithms in Bitbybit.",
+        "slug": "/code/common/base/math"
+    }
+}

docs/learn/code/common/base/math/intro.md

@@ -0,0 +1,80 @@
+---
+sidebar_position: 2
+title: Math in Bitbybit
+sidebar_label: Math in Bitbybit
+description: An overview of the Math class in Bitbybit, providing tools for common mathematical operations, number generation, and easing functions.
+tags: [code, math]
+---
+
+<img 
+  src="https://s.bitbybit.dev/assets/icons/white/math-icon.svg" 
+  alt="Vector category icon" 
+  title="Vector category icon"
+  width="100" /> 
+
+[View Full Source & Details on GitHub](https://github.com/bitbybit-dev/bitbybit/blob/master/packages/dev/base/lib/api/services/math.ts)
+
+The `MathBitByBit` class (often referred to as `Math` in examples) is your go-to utility for a variety of numerical operations, from basic arithmetic to more specialized functions like easing and number generation.
+
+Many of its functions are convenient wrappers around standard JavaScript `Math` object methods, making them readily available within the Bitbybit ecosystem.
+
+## Core Capabilities of the Math Class
+
+Here's a breakdown of what the `Math` class offers. For precise input parameters, specific operator names (for `twoNrOperation` and `oneNrOperation`), and detailed behavior, please consult the [full Math API documentation](https://docs.bitbybit.dev/classes/Bit.MathBitByBit.html) or the GitHub source linked above.
+
+### 1. Basic Arithmetic & Number Operations
+
+These are the everyday math functions:
+*   **Fundamental Operations:** Add (`add`), subtract (`subtract`), multiply (`multiply`), divide (`divide`), and raise to a power (`power`). There's also a general `twoNrOperation()` that can perform these based on an operator type.
+*   **Single Number Functions:**
+    *   Get the square root (`sqrt`), absolute value (`abs`), or negate a number (`negate`).
+    *   Rounding: Round to the nearest integer (`round`), round down (`floor`), or round up (`ceil`). You can also round to a specific number of decimal places (`roundToDecimals()`).
+    *   Logarithms: Natural log (`ln`), base-10 log (`log10`).
+    *   Exponentials: `e` to the power of x (`exp`), 10 to the power of x (`tenPow`).
+    *   Modulus: Find the remainder of a division (`modulus()`).
+*   **Trigonometry:** Standard trigonometric functions like `sin()`, `cos()`, `tan()`, and their inverses (`asin()`, `acos()`, `atan()`).
+*   **Angle Conversion:** Convert between degrees and radians (`degToRad()`, `radToDeg()`).
+*   A general `oneNrOperation()` method can perform many of these single-number operations by specifying an operator type.
+
+### 2. Number Generation & Constants
+
+Creating numbers:
+*   **Specific Number:** Simply return a provided number (`number()`). This can be useful in visual programming environments.
+*   **Random Numbers:**
+    *   Generate a random number between 0 (inclusive) and 1 (exclusive) (`random()`).
+    *   Generate a random number within a specified range (low to high) (`randomNumber()`).
+    *   Generate a list of random numbers within a range (`randomNumbers()`).
+*   **Constants:** Get the value of Pi (`pi()`).
+
+### 3. Number Manipulation & Easing
+
+More advanced ways to work with numbers:
+*   **Remapping (`remap()`):** Take a number from one range and scale it proportionally to fit into a new range. For example, mapping a value from `0-100` to `0-1`.
+*   **Easing Functions (`ease()`):** This is a powerful feature for creating smooth transitions or non-linear progressions.
+    *   You provide an input value `x` (typically from 0 to 1), a target output range (`min` and `max`), and an `ease` type (e.g., `easeInSine`, `easeOutQuad`, `easeInOutElastic`).
+    *   The function transforms `x` according to the chosen easing curve and then maps it to your desired `min`-`max` range.
+    *   This is extremely useful for animations, procedural modeling where you want non-uniform distributions, and controlling behavior over time. The class includes a comprehensive set of standard easing functions (like Sine, Quad, Cubic, Expo, Bounce, etc., with In, Out, and InOut variations).
+*   **Fixed Decimal Representation (`toFixed()`):** Convert a number to a string, rounded to a specified number of decimal places.
+
+## How to Use
+
+Most methods in the `Math` class take an "inputs" object containing the number(s) and any necessary parameters.
+
+```typescript
+// Conceptual TypeScript example for adding two numbers
+const num1 = 10;
+const num2 = 5.5;
+
+const sum = bitbybit.math.add({ first: num1, second: num2 });
+// sum would be 15.5
+
+// Conceptual example for easing
+const easedValue = bitbybit.math.ease({
+    x: 0.5, // Halfway through the normalized input
+    min: 0,
+    max: 100,
+    ease: Bit.Inputs.Math.easeEnum.easeOutQuad // Example ease type
+});
+// easedValue would be 75, because easeOutQuad at 0.5 is 0.75,
+// and 0.75 remapped from 0-1 to 0-100 is 75.
+```

docs/learn/code/common/base/point/_category_.json

@@ -0,0 +1,10 @@
+{
+    "label": "Point",
+    "position": 4,
+    "link": {
+        "type": "generated-index",
+        "title": "Point Algorithms in Bitbybit",
+        "description": "Introduction to point algorithms in Bitbybit, including point creation, manipulation and analysis. Learn how to use these algorithms to work with points in 2D and 3D space.",
+        "slug": "/code/common/base/point"
+    }
+}

docs/learn/code/common/base/point/intro.md

@@ -0,0 +1,94 @@
+---
+sidebar_position: 1
+title: Points in Bitbybit
+sidebar_label: Points in Bitbybit
+description: Learn about the Point class in Bitbybit. Understand how to create, transform, and analyze points in your 3D projects.
+tags: [code, point]
+---
+
+[View Full Source & Details on GitHub](https://github.com/bitbybit-dev/bitbybit/blob/master/packages/dev/base/lib/api/services/point.ts)
+
+<img 
+  src="https://s.bitbybit.dev/assets/icons/white/point-icon.svg" 
+  alt="Vector category icon" 
+  title="Vector category icon"
+  width="100" /> 
+
+The `Point` class in Bitbybit provides essential tools for working with points in 3D space.
+
+**What is a Point in Bitbybit?**
+
+Just like a `Vector`, a `Point` in Bitbybit is fundamentally a simple **array of three numbers: `[x, y, z]`**.
+*   This means you can often use a `Point` where a `Vector` is expected, and vice-versa, as they share the same underlying structure.
+*   When working in 2D, the Z-coordinate is typically just set to `0`, so a 2D point looks like `[x, y, 0]`.
+
+This simplicity makes it easy to define locations and work with geometric data.
+
+## Core Capabilities of the Point Class
+
+The `Point` class is all about defining locations and manipulating them. Here's an overview of what it helps you do. For the nitty-gritty details of each function, including specific input parameters, please check the [full Point API documentation](https://docs.bitbybit.dev/classes/Bit.Point-1.html) or the GitHub source linked above.
+
+### 1. Creating Points & Point Patterns
+
+Need to define a point or a collection of points?
+*   **Basic Points:** Create individual 3D points from X, Y, and Z coordinates (`pointXYZ()`) or 2D points from X and Y (`pointXY()`, which creates `[x, y, 0]`).
+*   **Pattern Generation:**
+    *   `spiral()`: Generate points arranged in a spiral pattern.
+    *   `hexGrid()`: Create points that form the centers of a hexagonal grid.
+    *   `hexGridScaledToFit()`: A more advanced hexagonal grid generator that can scale the grid to fit specific dimensions and provides both center points and hexagon vertices.
+*   **Duplication:**
+    *   `multiplyPoint()`: Create multiple copies of the same point.
+
+### 2. Transforming Points (Moving, Rotating, Scaling)
+
+This is a major strength of the `Point` class. You can easily change the position, orientation, or size of points:
+*   **General Transformations:** Apply complex transformations (like those created by the `Transforms` class) to a single point (`transformPoint()`) or multiple points (`transformPoints()`). You can even apply a unique transformation to each point in a list (`transformsForPoints()`).
+*   **Translation (Moving):**
+    *   Move points by a single vector (`translatePoints()`, `translateXYZPoints()`).
+    *   Move each point in a list by its own unique translation vector (`translatePointsWithVectors()`).
+*   **Scaling (Resizing):**
+    *   Scale points around a center point using X, Y, Z scale factors (`scalePointsCenterXYZ()`).
+*   **Stretching:**
+    *   Stretch points along a specific direction from a center point (`stretchPointsDirFromCenter()`).
+*   **Rotation:**
+    *   Rotate points around an axis that passes through a center point (`rotatePointsCenterAxis()`).
+
+### 3. Analyzing and Measuring Points
+
+Get information about your points and their relationships:
+*   **Coordinates:** Get the individual X, Y, or Z coordinate of a point (`getX()`, `getY()`, `getZ()`).
+*   **Distance:**
+    *   Calculate the distance between two specific points (`distance()`).
+    *   Find the distances from one point to many other points (`distancesToPoints()`).
+*   **Closest Point:**
+    *   From a reference point, find the closest point in a list of other points (`closestPointFromPoints()`).
+    *   You can also get the *distance* to this closest point (`closestPointFromPointsDistance()`) or its *index* in the list (`closestPointFromPointsIndex()`).
+*   **Bounding Box:** Find the smallest box that encloses a set of points (`boundingBoxOfPoints()`). This gives you the minimum and maximum extent, center, and dimensions.
+*   **Average Point:** Calculate the average position of a group of points (`averagePoint()`).
+*   **Equality Check:** Determine if two points are in (almost) the same location, within a small tolerance (`twoPointsAlmostEqual()`).
+
+### 4. Calculating Normals and Fillets (More Advanced Geometry)
+
+*   **Normal Vector:** Calculate a normal vector (a vector perpendicular to a surface) from three points that define a plane (`normalFromThreePoints()`).
+*   **Fillet Radius Calculation:** Functions to help determine the maximum possible radius for a smooth, rounded corner (fillet) given points that define the corner (`maxFilletRadius()`, `maxFilletRadiusHalfLine()`, `maxFilletsHalfLine()`, `safestPointsMaxFilletHalfLine()`). These are useful for advanced modeling tasks like creating smooth transitions between edges.
+
+### 5. Utility and Cleaning
+
+*   **Removing Duplicates:** Clean up lists of points by removing consecutive identical points, considering a tolerance (`removeConsecutiveDuplicates()`).
+*   **Sorting:** Sort a list of points, primarily by X, then Y, then Z coordinates (`sortPoints()`).
+
+## How to Use
+
+Interacting with `Point` class methods typically involves providing an "inputs" object that contains the necessary data, like the point(s) themselves and any parameters for the operation.
+
+```typescript
+// Conceptual TypeScript example for translating a point
+const myPoint = [10, 20, 0];
+const translationVector = [5, 0, 5];
+
+const movedPoint = bitbybit.point.translatePoints({
+    points: [myPoint],
+    translation: translationVector
+});
+// movedPoint would be [[15, 20, 5]]
+```

docs/learn/code/common/base/vector/_category_.json

@@ -0,0 +1,10 @@
+{
+    "label": "Vector",
+    "position": 3,
+    "link": {
+        "type": "generated-index",
+        "title": "Vector Algorithms in Bitbybit",
+        "description": "Introduction to vector algorithms in Bitbybit, including vector addition, subtraction and other operations. Learn how to use these algorithms to manipulate and analyze vector data.",
+        "slug": "/code/common/base/vector"
+    }
+}

docs/learn/code/common/base/vector/intro.md

@@ -0,0 +1,97 @@
+---
+sidebar_position: 1
+title: Vectors in Bitbybit
+sidebar_label: Vectors in Bitbybit
+description: An overview of the Vector class in Bitbybit, explaining its core functionalities for vector math in simple terms.
+tags: [code, vector]
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img 
+  src="https://s.bitbybit.dev/assets/icons/white/vector-icon.svg" 
+  alt="Vector category icon" 
+  title="Vector category icon"
+  width="100" /> 
+
+The `Vector` class in Bitbybit provides a comprehensive suite of tools for performing vector mathematics. In Bitbybit, a **vector is fundamentally represented as an array of numbers**. For 3D operations, this typically takes the form `[x, y, z]`, where `y` is considered the 'up' direction by convention in many Bitbybit contexts. This simple array representation means that vectors can often be used interchangeably with points, which also follow the `[x, y, z]` structure.
+
+[Full Source on GitHub](https://github.com/bitbybit-dev/bitbybit/blob/master/packages/dev/base/lib/api/services/vector.ts)
+
+
+The `Vector` class in Bitbybit is your toolkit for working with vectors and points in your 3D designs.
+
+**What is a Vector in Bitbybit?**
+
+At its heart, a vector (or a point) in Bitbybit is just a simple **array of numbers**.
+*   For 2D, it might look like `[x, y]`.
+*   For 3D, it's typically `[x, y, z]`. In many Bitbybit contexts, `y` represents the "up" direction.
+
+This straightforward representation makes it easy to pass vector data around and use it in various calculations.
+
+## What Can You Do With the Vector Class?
+
+The `Vector` class helps you perform a wide range of operations. Here's a look at the main categories of features it supports. For the exact input parameters, default values, and more advanced functions, please consult the detailed [Vector API Documentation](https://docs.bitbybit.dev/classes/Bit.Vector-1.html) (or the GitHub source linked above).
+
+### 1. Creating Vectors and Number Sequences
+
+Need to make a new vector or a list of numbers?
+*   **Specific Vectors:** Create 2D (`[x,y]`) or 3D (`[x,y,z]`) vectors directly from their components (e.g., `vectorXYZ()`, `vectorXY()`).
+*   **Number Ranges:** Generate sequences of numbers.
+    *   `range()`: Get a simple list of integers (e.g., `[0, 1, 2, 3, 4]`).
+    *   `span()`: Create evenly spaced numbers between a minimum and maximum (e.g., `[0, 0.5, 1.0, 1.5, 2.0]`).
+    *   `spanLinearItems()`: Like `span()`, but you specify the total number of items you want.
+    *   `spanEaseItems()`: Create a sequence where the spacing follows an "easing" curve (e.g., numbers bunch up at the start and spread out at the end). This is great for animations or non-uniform distributions.
+
+### 2. Basic Vector Math (The Essentials)
+
+These are the bread-and-butter operations:
+*   **Addition & Subtraction:** Add two vectors (`add()`) or subtract one from another (`sub()`). You can also sum up a whole list of vectors (`addAll()`).
+*   **Scaling (Multiplication/Division):** Make a vector longer or shorter by multiplying (`mul()`) or dividing (`div()`) its components by a single number (a scalar).
+*   **Dot Product (`dot()`):** A fundamental operation that tells you about the relationship between two vectors' directions.
+*   **Cross Product (`cross()`):** For 3D vectors, this gives you a new vector that's perpendicular to the two original vectors. Essential for finding normals or rotational axes.
+*   **Negation (`neg()`):** Flip the direction of a vector.
+
+### 3. Measuring and Analyzing Vectors
+
+Understand your vectors' properties:
+*   **Length (Magnitude/Norm):** Find out how long a vector is (`length()`, `norm()`). There are also versions for squared length (`lengthSq()`, `normSquared()`), which can be faster if you only need to compare lengths.
+*   **Normalization (`normalized()`):** Create a "unit vector" – a vector with a length of 1 that points in the same direction as the original. Very useful for representing directions.
+*   **Distance:** Calculate the distance between two points (which are just vectors) (`dist()`, `distSquared()`).
+*   **Angles:**
+    *   Measure the angle between two vectors (`angleBetween()`).
+    *   Get signed angles or positive angles relative to a reference direction (`signedAngleBetween()`, `positiveAngleBetween()`, `angleBetweenNormalized2d()`). This helps determine orientation (e.g., clockwise vs. counter-clockwise).
+*   **Interpolation (`lerp()`):** Find a point (vector) that's part-way between two other points, based on a fraction.
+
+### 4. Validating and Checking Vectors
+
+Perform checks on your vector data:
+*   **Are Vectors the Same? (`vectorsTheSame()`):** Check if two vectors are equal, within a small tolerance (important for floating-point numbers).
+*   **Is it Zero? (`isZero()`):** See if a vector has zero length.
+*   **Is it Finite? (`finite()`):** Check if all numbers in a vector are valid (not Infinity or NaN).
+
+### 5. Working with Lists of Vectors
+
+Manage collections of vectors:
+*   **Removing Duplicates:** Clean up lists by removing identical vectors, either all duplicates (`removeAllDuplicateVectors()`) or only those that are next to each other (`removeConsecutiveDuplicateVectors()`).
+*   **Finding Min/Max Values (`min()`, `max()`):** Get the smallest or largest number within a vector's components.
+*   **Domain (`domain()`):** For an ordered list of numbers, find the difference between the last and first values.
+
+### 6. Utility Functions
+
+*   **Point on Ray (`onRay()`):** Given a starting point, a direction vector, and a distance, find the coordinates of the point along that ray.
+*   **Boolean List Check (`all()`):** Check if a list of boolean values are all `true`.
+
+## How to Use
+
+Typically, you'll interact with these methods by providing an "inputs" object. For example, to add two vectors:
+
+```typescript
+// In TypeScript (conceptual)
+const vec1 = [1, 2, 3];
+const vec2 = [4, 5, 6];
+
+const sumVector = bitbybit.vector.add({ first: vec1, second: vec2 });
+// sumVector will be [5, 7, 9]
+```