Find distance between 2D point and line segment start point

This feels like a simple problem but I am bad at algebra.

I'm trying to find the distance between a point and the start of a line segment at an angle parallel to the segment. I will use the distance to interpolate a value along the line.

I also need to know when the points are outside of the line.

A code example would be appreciated, this is my attempt so far using threejs Vector2D but it isn't behaving as expected.

const lineStartOrig = lineStart.clone()

const lineLength = lineStart.distanceTo(lineEnd)

const dotDiff = point2D.sub(lineStart).dot(lineEnd) / lineEnd.dot(lineEnd)


const pointIntersect = dummyLineStart.add(lineEnd)
                                     .multiplyScalar(dotDiff)
                                     .clamp(lineStartOrig, lineEnd)

const value = pointIntersect.distanceTo(lineStartOrig) / lineLength

In case it's useful to anyone, I used the following functions (unfortunately not in .js, but should illustrate the idea)

To calc angle between two vectors and a test point C:

float calcAngle(QVector2D& A, QVector2D& B, QVector2D& C)
{
    QVector2D v1 = B - A;
    QVector2D v2 = C - A;
    float v1DotV2 = QVector2D::dotProduct(v1, v2);
    float magV1TimesMagV2 = v1.length()* v2.length();
    float cosTheta = v1DotV2/magV1TimesMagV2;
    float theta = qRadiansToDegrees(acosf(cosTheta));
    qInfo() << "Theta " << theta;

    return theta;
}

To get the distance and intersect point which I think the OP is after:

float calcDistAlongParallelLineAndIntersectPoint(const QVector2D& A, const QVector2D& B, const QVector2D& C, QVector2D& intersectPoint)
{
    QVector2D v1 = B - A;
    QVector2D v2 = C - A;
    float v1DotV2 = QVector2D::dotProduct(v1, v2);
    float magV1TimesMagV2 = v1.length()* v2.length();
    float cosTheta = v1DotV2/magV1TimesMagV2;
    float dist = v2.length() * cosTheta;

    QVector2D intersectingPoint = C - v1*(dist/v1.length());
    intersectPoint.setX(intersectingPoint.x());
    intersectPoint.setY(intersectingPoint.y());
    return dist;
}

A little check for some random points gives:

I went in a slightly different direction but Gremto's answer helped a lot and correctly answered the question so I'm marking that as the solution.

I solved the problem using a gradient function that I found here: https://www.shadertoy.com/view/lscGDr

It's in GLSL but here's my ts version using three.js's Vector2

interface Line2D {
    x1: number,
    x2: number,
    y1: number,
    y2: number
}  

const dummyLineStart = new Vector2(0, 0)
const dummyLineEnd = new Vector2(0, 0)
const dummyPoint = new Vector2(0, 0)
const dummyLineEndTranslated = new Vector2(0, 0)

//provides an interpolation value between 0 and 1 for a point depending on its 
relative parallel position to a line

//points before the start of the line will return 1
function interpolatePointValueAlongLine(
    line: Line2D,
    pointX: number,
    pointY: number
) {

    //use reusable vecs to prevent reinitialising class every call
    dummyLineStart.set(line.x1, line.y1)
    dummyLineEnd.set(line.x2, line.y2)
    dummyPoint.set(pointX, pointY)

    //code from: https://www.shadertoy.com/view/lscGDr
    dummyLineEndTranslated.set(line.x2, line.y2)
                          .sub(dummyLineStart)

    return dummyPoint.sub(dummyLineStart)
                     .dot(dummyLineEndTranslated) / 
    dummyLineEndTranslated.dot(dummyLineEndTranslated)
}