@neo4j-nvl/base 0.3.1-854a900a

package/dist/types/utils/errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Specific error that is being thrown by NVL when web browser is not WebGL compatible.
+ * @internal
+ */
+export declare class CompatibilityError extends Error {
+    /**
+     * Returns the error message of the compatibility error.
+     * @returns {string} the error message
+     */
+    toString(): string;
+}

package/dist/types/utils/geometry.d.ts

@@ -0,0 +1,122 @@
+import type { Node } from '../types/graph-element';
+/**
+ * An object representing a point in 2D space.
+ */
+export interface Point {
+    /** The x coordinate of the point. */
+    x: number;
+    /** The y coordinate of the point. */
+    y: number;
+}
+/**
+ * This function checks if the coordinates are defined.
+ * @param {Point} from - The node the edge starts from.
+ * @param {Point} to - The node the edge ends at.
+ * @returns {boolean} True if the coordinates are defined.
+ */
+export declare const areCoordinateDefined: (from: Point, to: Point) => boolean;
+/**
+ * Returns true if the two points are within PointDelta pixels of each other
+ * This function is used to determine if a new point is close enough to an
+ * existing point to be considered the same point
+ * @param {Node} p1 - The first point.
+ * @param {Node} p2 - The second point.
+ * @returns {boolean} True if the two points are within PointDelta pixels of each other.
+ */
+export declare const pointEqual: (p1: Node | Point, p2: Node | Point) => boolean;
+/**
+ * A class representing a line segment between two points in 2D space.
+ * @param {Point} p1 - The first point of the segment.
+ * @param {Point} p2 - The second point of the segment.
+ */
+export declare class Segment {
+    /** The first point of the segment. */
+    readonly p1: Point;
+    /** The second point of the segment. */
+    readonly p2: Point;
+    /** The unit vector of the segment. */
+    readonly unit: Point;
+    /** The unit normal vector of the segment. */
+    readonly norm: Point;
+    /** The length of the segment. */
+    readonly length: number;
+    /** The vector between the two points of the segment. */
+    readonly vector: Point;
+    constructor(p1: Point, p2: Point);
+    /**
+     * Get the vector between the two points of the segment.
+     * @returns {Point} The vector between the two points of the segment.
+     * @private
+     * @see {@link https://en.wikipedia.org/wiki/Vector_(spatial)}
+     */
+    private getVector;
+    /**
+     * Get the length of the vector between the two points of the segment.
+     * @returns {number} The length of the segment.
+     * @private
+     * @see {@link https://en.wikipedia.org/wiki/Vector_(spatial)#Length}
+     */
+    private getLength;
+    /**
+     * Get the unit vector of the two points of the segment.
+     * @returns {Point} The unit vector of the segment.
+     * @private
+     * @see {@link https://en.wikipedia.org/wiki/Euclidean_vector#Unit_vector}
+     * @see {@link https://en.wikipedia.org/wiki/Unit_vector}
+     */
+    private getUnitVector;
+    /**
+     * Get the unit normal vector of the two points of the segment.
+     * @returns {Point} The unit normal vector of the segment.
+     * @private
+     * @see {@link https://en.wikipedia.org/wiki/Normal_(geometry)}
+     */
+    private getUnitNormalVector;
+}
+/**
+ * Calculates the projection ratio between two vectors.
+ * @param {Point} lineStartToPointVector - The vector from the start of the line to the point.
+ * @param {Point} lineVector - The vector of the line.
+ * @returns {number} The projection of the point onto the line.
+ * @note The projection ratio is a value between 0 and 1.
+ * @note The projection ratio is 0 if the point is closest to the start of the line.
+ * @note The projection ratio is 1 if the point is closest to the end of the line.
+ * @see {@link https://en.wikipedia.org/wiki/Vector_projection}
+ */
+export declare const getProjectionRatio: (lineStartToPointVector: Point, lineVector: Point) => number;
+/**
+ * Calculates the shortest distance between a point and a line.
+ * @param {Point} lineStart - The first point of the line.
+ * @param {Point} lineEnd - The second point of the line.
+ * @param {Point} point - The point to calculate the distance to.
+ * @returns {number} The distance between the point and the line.
+ * @note If the actual distance does not matter,
+ * if you only want to compare what this function
+ * returns to other results of this function, you
+ * can just return the squared distance instead
+ * (i.e. remove the sqrt) to gain a little performance.
+ */
+export declare const getDistanceToLine: (lineStart: Point, lineEnd: Point, point: Point) => number;
+/**
+ * Get the intersection point of two lines
+ * @param {Point} p0 - First point of first line
+ * @param {Point} p1 - Second point of first line
+ * @param {Point} p2 - First point of second line
+ * @param {Point} p3 - Second point of second line
+ * @returns {Point | null} Intersection point
+ * @see https://github.com/bit101/CodingMath/blob/master/episode33/parallel.js
+ * @note Returns null if lines are parallel
+ */
+export declare const getIntersection: (p0: Point, p1: Point, p2: Point, p3: Point) => Point | null;
+/**
+ * This is a function to calculate the distance between a point and a quadratic curve.
+ * The curve is defined by three points (from, to, control).
+ * The point is defined by an object with x and y properties (point).
+ * The function returns the distance between the point and the curve.
+ * @param {Point} fromCoordinates - The first point of the curve.
+ * @param {Point} toCoordinates - The second point of the curve.
+ * @param {Point} control - The control point of the curve.
+ * @param {Point} point - The point to calculate the distance to.
+ * @returns {number} The distance between the point and the curve.
+ */
+export declare const getDistanceToQuadratic: (fromCoordinates: Point, toCoordinates: Point, control: Point, point: Point) => number;

package/dist/types/utils/graphObjectUtils.d.ts

@@ -0,0 +1,9 @@
+export function relItemsToFlatList(relItems: any[]): any[];
+export function getAdjNodesMapAndRelMap(rels: any): {
+    adjNodesMap: {};
+    relMap: {};
+};
+export function getConnectedNodesAndRels(addedNodes: any, addedRels: any, nodes: any, rels: any): {
+    connectedNodes: {};
+    connectedRels: {};
+};

package/dist/types/utils/hittest.d.ts

@@ -0,0 +1,56 @@
+import type { NvlState } from '../modules/state';
+import type { Node, Relationship } from '../types/graph-element';
+import type { Point } from './geometry';
+/**
+ * A node that has been hit by a pointer event
+ */
+export interface HitTargetNode {
+    /** The node that was hit */
+    data: Node;
+    /** The coordinates of the node that was hit */
+    targetCoordinates: Point;
+    /** The coordinates of the pointer event */
+    pointerCoordinates: Point;
+    /** The distance vector between the node and the pointer event */
+    distanceVector: Point;
+    /** The distance between the node and the pointer event */
+    distance: number;
+    /** Whether the pointer event is inside the node */
+    insideNode: boolean;
+}
+/**
+ * A relationship that has been hit by a pointer event
+ */
+export interface HitTargetRelationship {
+    /** The relationship that was hit */
+    data: Relationship;
+    /** The coordinates of the source node of the relationship that was hit */
+    fromTargetCoordinates: Point;
+    /** The coordinates of the target node of the relationship that was hit */
+    toTargetCoordinates: Point;
+    /** The coordinates of the pointer event */
+    pointerCoordinates: Point;
+    /** The distance between the relationship and the pointer event */
+    distance: number;
+}
+/**
+ * A collection of nodes and relationships that have been hit by a pointer event
+ * Part of the result of a {@link NVL}.{@link NVL.getHits} call
+ */
+export type HitTargets = {
+    nodes: HitTargetNode[];
+    relationships: HitTargetRelationship[];
+};
+export declare const hitTest: (x: number, y: number, state: NvlState, targets?: string[], options?: {
+    hitNodeMarginWidth?: number;
+}) => HitTargets;
+export declare const hitTestCanvas: (x: number, y: number, parentHandler: {
+    getCanvasNodesAt: (c: Point, m: number) => HitTargetNode[];
+    getCanvasRelsAt: (c: Point) => HitTargetRelationship[];
+}, targets?: string[], options?: {
+    hitNodeMarginWidth?: number;
+}) => HitTargets;
+export declare const hitTestBox: (x1: number, y1: number, x2: number, y2: number, state: NvlState, targets?: string[]) => {
+    nodes: Node[];
+    rels: Relationship[];
+};

package/dist/types/utils/mouseUtils.d.ts

@@ -0,0 +1,9 @@
+export declare const getMouseElementCoordinates: (evt: MouseEvent, element: HTMLElement) => {
+    offsetX: number;
+    offsetY: number;
+};
+export declare const getMousePosition: (evt: MouseEvent, canvas: HTMLElement, zoom?: number, panX?: number, panY?: number) => {
+    x: number;
+    y: number;
+};
+export declare const getNewZoom: (evt: WheelEvent, currentZoom?: number) => number;

package/dist/types/utils/zoomFunctions.d.ts

@@ -0,0 +1,20 @@
+import type { Node } from '../index';
+import type { Point } from './geometry';
+declare const getExtremeLimits: (nodePositions: Point[] | Node[]) => Point[];
+declare const getMaxDistance: (extremeLimits?: Point[]) => number;
+declare const getPositionBoundaries: (nodePositions?: Point[] | Node[], maxNodeRadius?: number) => {
+    centerX: number;
+    centerY: number;
+    nodesWidth: number;
+    nodesHeight: number;
+};
+declare const getZoomLevel: (viewWidth: number, viewHeight: number, sceneWidth: number, sceneHeight: number) => {
+    zoomX: number;
+    zoomY: number;
+};
+declare const createZoomTarget: (zoomX: number, zoomY: number, minZoom?: number, maxZoom?: number) => number;
+declare const getFlexibleZoomLimit: (nodePositions: Point[] | Node[], rect: HTMLCanvasElement, maxNodeRadius: number) => number;
+declare const getNewZoomWithinLimits: (newZoom: number, oldZoom: number, minZoom: number, maxZoom: number) => number;
+declare const isZoomOutAtLimit: (newZoom: number, oldZoom: number, zoomOutLimit: number) => boolean;
+declare const getDynamicZoom: (nodePositions: Point[] | Node[], minZoom: number, maxZoom: number, rect: HTMLCanvasElement, newZoom: number, currentZoom: number) => number;
+export { getFlexibleZoomLimit, isZoomOutAtLimit, getNewZoomWithinLimits, getExtremeLimits, getMaxDistance, getPositionBoundaries, getZoomLevel, createZoomTarget, getDynamicZoom };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@neo4j-nvl/base",
+  "version": "0.3.1-854a900a",
+  "license": "SEE LICENSE IN 'LICENSE.txt'",
+  "main": "dist/base.mjs",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "LICENSE.txt",
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf lib/ dist/ && tsc && webpack",
+    "test": "jest",
+    "coverage": "yarn test --coverage --silent",
+    "prepack": "cp ../../LICENSE.txt ./",
+    "postpack": "rm LICENSE.txt"
+  },
+  "typedoc": {
+    "entryPoint": "./src/index.ts",
+    "readmeFile": "./README.md",
+    "displayName": "Base",
+    "tsconfig": "./tsconfig.json"
+  },
+  "dependencies": {
+    "@neo4j-nvl/layout-workers": "^0.3.1-854a900a",
+    "color-string": "^1.9.1",
+    "contrast": "1.0.1",
+    "d3-force": "^3.0.0",
+    "gl-matrix": "^3.3.0",
+    "glsl-inject-defines": "^1.0.3",
+    "lodash": "4.17.21",
+    "loglevel": "^1.8.0",
+    "mobx": "^3.2.2",
+    "node-pid-controller": "^1.0.1",
+    "resizelistener": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/color-string": "^1.5.5",
+    "@types/d3-force": "^3.0.3",
+    "@types/lodash": "4.14.202",
+    "babel-loader": "^8.2.5",
+    "copy-webpack-plugin": "^11.0.0",
+    "jest": "^29.7.0",
+    "typedoc": "^0.23.15",
+    "typescript": "^5.4.5",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.0"
+  },
+  "peerDependencies": {
+    "jest": "*",
+    "typescript": "*"
+  },
+  "stableVersion": "0.3.1"
+}