diff --git a/CHANGELOG.md b/CHANGELOG.md index eebd5f4..c9fca10 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,28 @@ # Change logs for Labella.js +## v2.x.x + +### 2.0.0 (2026-05-31) + +Complete rewrite in TypeScript with a modern toolchain. No API changes — all existing code using `labella.Node`, `labella.Force`, `labella.Distributor`, `labella.Renderer`, `labella.metrics` and `labella.util` continues to work unchanged. + +#### Toolchain + +- Replace Gulp + webpack + Karma with **Rollup + Vitest + Vite** +- Build outputs: `labella.js` (ESM), `labella.cjs` (CJS), `labella.umd.js`, `labella.umd.min.js`, `labella.d.ts` (bundled type declarations) +- `"type": "module"` — package is now pure ESM-first with CJS interop via exports map + +#### TypeScript migration + +- All `src/core/` and `src/lib/` files converted to TypeScript with strict mode enabled +- Native type declarations included — no `@types/labella` needed +- `vpsc` vendored from WebCola as `src/lib/vpsc.ts` — no new runtime dependency + +#### Demo + +- Replace Bower with CDN links at exact same dependency versions (d3 v3.5.17, d3kit v1.0.9, Angular v1.4.8, Bootstrap 3.4.1) +- `npm run dev` now serves the demo via Vite from the repo root + ## v1.x.x ### 1.1.4 (2017-05-24) diff --git a/dist/core/distributor.d.ts b/dist/core/distributor.d.ts new file mode 100644 index 0000000..d391776 --- /dev/null +++ b/dist/core/distributor.d.ts @@ -0,0 +1,28 @@ +import { Node } from './labelNode.js'; +export interface DistributorOptions { + algorithm?: string | ((nodes: Node[], options: DistributorOptions) => Node[][]); + layerWidth?: number | null; + density?: number; + nodeSpacing?: number; + stubWidth?: number; +} +declare const DEFAULT_OPTIONS: Required> & { + algorithm: string; +}; +export interface Distributor { + options(): DistributorOptions; + options(x: DistributorOptions): Distributor; + computeRequiredWidth(nodes: Node[]): number; + maxWidthPerLayer(): number; + needToSplit(nodes: Node[]): boolean; + estimateRequiredLayers(nodes: Node[]): number; + countIdealOverlaps(nodes: Node[]): Node[]; + distribute(nodes: Node[]): Node[][]; +} +interface DistributorConstructor { + (initOptions?: DistributorOptions): Distributor; + DEFAULT_OPTIONS: typeof DEFAULT_OPTIONS; +} +declare const Distributor: DistributorConstructor; +export { Distributor }; +export default Distributor; diff --git a/dist/core/force.d.ts b/dist/core/force.d.ts new file mode 100644 index 0000000..36e5b91 --- /dev/null +++ b/dist/core/force.d.ts @@ -0,0 +1,39 @@ +import { DistributorOptions } from './distributor.js'; +import { Node } from './labelNode.js'; +export interface ForceOptions { + nodeSpacing?: number; + minPos?: number | null; + maxPos?: number | null; + algorithm?: string | ((nodes: Node[], options: DistributorOptions) => Node[][]); + removeOverlap?: boolean; + density?: number; + stubWidth?: number; + lineSpacing?: number; + layerWidth?: number | null; +} +declare const DEFAULT_OPTIONS: { + nodeSpacing: number; + minPos: number | null; + maxPos: null; + algorithm: string; + removeOverlap: boolean; + density: number; + stubWidth: number; + lineSpacing: number; +}; +export interface Force { + nodes(): Node[]; + nodes(x: Node[]): Force; + getLayers(): Node[][] | null; + options(): ForceOptions; + options(x: ForceOptions): Force; + compute(): Force; + start(): void; +} +interface ForceConstructor { + (_options?: ForceOptions): Force; + DEFAULT_OPTIONS: typeof DEFAULT_OPTIONS; +} +declare const Force: ForceConstructor; +export { Force }; +export default Force; diff --git a/dist/core/helper.d.ts b/dist/core/helper.d.ts new file mode 100644 index 0000000..14da9d8 --- /dev/null +++ b/dist/core/helper.d.ts @@ -0,0 +1,9 @@ +import extend from '../lib/extend.js'; +declare const helper: { + isDefined(x: unknown): boolean; + last(array: T[]): T | null; + pick(object: T, keys: K[]): Pick; + sum(array: T[], accessor: (item: T, index: number) => number): number; + extend: typeof extend; +}; +export default helper; diff --git a/dist/core/labelNode.d.ts b/dist/core/labelNode.d.ts new file mode 100644 index 0000000..f69dec2 --- /dev/null +++ b/dist/core/labelNode.d.ts @@ -0,0 +1,41 @@ +export declare class LabelNode { + idealPos: number; + currentPos: number; + width: number; + data: T | undefined; + layerIndex: number; + parent: LabelNode | null; + child: LabelNode | null; + overlaps?: LabelNode[]; + overlapCount?: number; + targetPos?: number; + index?: number; + x?: number; + y?: number; + dx?: number; + dy?: number; + constructor(idealPos: number, width: number, data?: T); + /** Returns negative if nodes overlap */ + distanceFrom(node: LabelNode): number; + moveToIdealPosition(): this; + displacement(): number; + overlapWithNode(node: LabelNode, buffer?: number): boolean; + overlapWithPoint(pos: number): boolean; + positionBefore(node: LabelNode, buffer?: number): number; + positionAfter(node: LabelNode, buffer?: number): number; + currentRight(): number; + currentLeft(): number; + idealRight(): number; + idealLeft(): number; + createStub(width?: number): LabelNode; + removeStub(): this; + isStub(): boolean; + getPathToRoot(): LabelNode[]; + getPathFromRoot(): LabelNode[]; + getPathToRootLength(): number; + getRoot(): LabelNode; + getLayerIndex(): number; + clone(): LabelNode; +} +export { LabelNode as Node }; +export default LabelNode; diff --git a/dist/core/metrics.d.ts b/dist/core/metrics.d.ts new file mode 100644 index 0000000..42ee360 --- /dev/null +++ b/dist/core/metrics.d.ts @@ -0,0 +1,14 @@ +import { Node } from './labelNode.js'; +type NodeOrLayer = Node | Node[]; +type LayersInput = NodeOrLayer[]; +export declare const metrics: { + displacement(nodes: LayersInput): number; + pathLength(nodes: LayersInput): number; + overflowSpace(nodes: LayersInput, minPos?: number | null, maxPos?: number | null): number; + overDensitySpace(nodes: LayersInput, density?: number | null, layerWidth?: number | null, nodeSpacing?: number): number; + overlapCount(nodes: LayersInput, buffer?: number): number; + overlapSpace(nodes: LayersInput): number; + weightedAllocation(nodes: LayersInput): number; + weightedAllocatedSpace(nodes: LayersInput): number; +}; +export default metrics; diff --git a/dist/core/node.d.ts b/dist/core/node.d.ts new file mode 100644 index 0000000..d53cd21 --- /dev/null +++ b/dist/core/node.d.ts @@ -0,0 +1,40 @@ +export declare class Node { + idealPos: number; + currentPos: number; + width: number; + data: T | undefined; + layerIndex: number; + parent: Node | null; + child: Node | null; + overlaps?: Node[]; + overlapCount?: number; + targetPos?: number; + index?: number; + x?: number; + y?: number; + dx?: number; + dy?: number; + constructor(idealPos: number, width: number, data?: T); + /** Returns negative if nodes overlap */ + distanceFrom(node: Node): number; + moveToIdealPosition(): this; + displacement(): number; + overlapWithNode(node: Node, buffer?: number): boolean; + overlapWithPoint(pos: number): boolean; + positionBefore(node: Node, buffer?: number): number; + positionAfter(node: Node, buffer?: number): number; + currentRight(): number; + currentLeft(): number; + idealRight(): number; + idealLeft(): number; + createStub(width?: number): Node; + removeStub(): this; + isStub(): boolean; + getPathToRoot(): Node[]; + getPathFromRoot(): Node[]; + getPathToRootLength(): number; + getRoot(): Node; + getLayerIndex(): number; + clone(): Node; +} +export default Node; diff --git a/dist/core/removeOverlap.d.ts b/dist/core/removeOverlap.d.ts new file mode 100644 index 0000000..9fd67dd --- /dev/null +++ b/dist/core/removeOverlap.d.ts @@ -0,0 +1,13 @@ +import { Node } from './labelNode.js'; +export interface RemoveOverlapOptions { + lineSpacing?: number; + nodeSpacing?: number; + minPos?: number | null; + maxPos?: number | null; +} +declare function removeOverlap(nodes: Node[], options?: RemoveOverlapOptions): Node[]; +declare namespace removeOverlap { + var DEFAULT_OPTIONS: Required; +} +export { removeOverlap }; +export default removeOverlap; diff --git a/dist/core/renderer.d.ts b/dist/core/renderer.d.ts new file mode 100644 index 0000000..5702c64 --- /dev/null +++ b/dist/core/renderer.d.ts @@ -0,0 +1,27 @@ +import { Node } from './labelNode.js'; +export type Direction = 'down' | 'up' | 'left' | 'right'; +export interface RendererOptions { + layerGap?: number; + nodeHeight?: number; + direction?: Direction; +} +type Point = [number, number]; +type Waypoints = Point[][]; +declare function lineTo(point: Point): string; +declare function moveTo(point: Point): string; +declare function curveTo(c1: Point, c2: Point, point2: Point): string; +declare function vCurveBetween(point1: Point, point2: Point): string; +declare function hCurveBetween(point1: Point, point2: Point): string; +export declare class Renderer { + options: Required; + static lineTo: typeof lineTo; + static moveTo: typeof moveTo; + static curveTo: typeof curveTo; + static vCurveBetween: typeof vCurveBetween; + static hCurveBetween: typeof hCurveBetween; + constructor(options?: RendererOptions); + getWaypoints(node: Node): Waypoints; + layout(nodes: Node[]): Node[]; + generatePath(node: Node): string; +} +export default Renderer; diff --git a/dist/core/util.d.ts b/dist/core/util.d.ts new file mode 100644 index 0000000..ddb2823 --- /dev/null +++ b/dist/core/util.d.ts @@ -0,0 +1,11 @@ +import { Node } from './labelNode.js'; +export interface GenerateNodesOptions { + minWidth?: number; + maxWidth?: number; + minPos?: number; + maxPos?: number; +} +export declare const util: { + generateNodes(amount: number, options?: GenerateNodesOptions): Node[]; +}; +export default util; diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..d950913 --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,10 @@ +export { Node } from './core/labelNode.js'; +export { Force } from './core/force.js'; +export type { ForceOptions } from './core/force.js'; +export { Distributor } from './core/distributor.js'; +export type { DistributorOptions } from './core/distributor.js'; +export { Renderer } from './core/renderer.js'; +export type { RendererOptions, Direction } from './core/renderer.js'; +export { metrics } from './core/metrics.js'; +export { util } from './core/util.js'; +export type { GenerateNodesOptions } from './core/util.js'; diff --git a/dist/labella.cjs b/dist/labella.cjs new file mode 100644 index 0000000..46b2c54 --- /dev/null +++ b/dist/labella.cjs @@ -0,0 +1,1424 @@ +'use strict'; + +class LabelNode { + constructor(idealPos, width, data) { + this.idealPos = idealPos; + this.currentPos = idealPos; + this.width = width; + this.data = data; + this.layerIndex = 0; + this.parent = null; + this.child = null; + } + /** Returns negative if nodes overlap */ + distanceFrom(node) { + const halfWidth = this.width / 2; + const nodeHalfWidth = node.width / 2; + return (Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - + Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth)); + } + moveToIdealPosition() { + this.currentPos = this.idealPos; + return this; + } + displacement() { + return this.idealPos - this.currentPos; + } + overlapWithNode(node, buffer = 0) { + return this.distanceFrom(node) - buffer < 0; + } + overlapWithPoint(pos) { + const halfWidth = this.width / 2; + return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; + } + positionBefore(node, buffer = 0) { + return node.currentLeft() - this.width / 2 - buffer; + } + positionAfter(node, buffer = 0) { + return node.currentRight() + this.width / 2 + buffer; + } + currentRight() { + return this.currentPos + this.width / 2; + } + currentLeft() { + return this.currentPos - this.width / 2; + } + idealRight() { + return this.idealPos + this.width / 2; + } + idealLeft() { + return this.idealPos - this.width / 2; + } + createStub(width) { + const stub = new LabelNode(this.idealPos, width !== null && width !== void 0 ? width : this.width, this.data); + stub.currentPos = this.currentPos; + stub.child = this; + this.parent = stub; + return stub; + } + removeStub() { + if (this.parent) { + this.parent.child = null; + this.parent = null; + } + return this; + } + isStub() { + return !!this.child; + } + getPathToRoot() { + const path = []; + let current = this; + while (current) { + path.push(current); + current = current.parent; + } + return path; + } + getPathFromRoot() { + return this.getPathToRoot().reverse(); + } + getPathToRootLength() { + let length = 0; + let current = this; + while (current) { + const targetPos = current.parent ? current.parent.currentPos : current.idealPos; + length += Math.abs(current.currentPos - targetPos); + current = current.parent; + } + return length; + } + getRoot() { + let previous = this; + let current = this; + while (current) { + previous = current; + current = current.parent; + } + return previous; + } + getLayerIndex() { + return this.layerIndex; + } + clone() { + const node = new LabelNode(this.idealPos, this.width, this.data); + node.currentPos = this.currentPos; + node.layerIndex = this.layerIndex; + return node; + } +} + +/* +This file is modified from https://github.com/justmoon/node-extend +The MIT License (MIT) + +Copyright (c) 2014 Stefan Thomas +*/ +const hasOwn = Object.prototype.hasOwnProperty; +const toStr = Object.prototype.toString; +function isArray(arr) { + return Array.isArray(arr); +} +function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + const o = obj; + const has_own_constructor = hasOwn.call(o, 'constructor'); + const ctor = o.constructor; + const has_is_property_of_method = ctor && ctor.prototype && hasOwn.call(ctor.prototype, 'isPrototypeOf'); + if (ctor && !has_own_constructor && !has_is_property_of_method) { + return false; + } + let key; + for (key in o) { + // intentionally empty + } + return key === undefined || hasOwn.call(o, key); +} +function extend(...args) { + let target; + let i = 1; + const length = args.length; + let deep = false; + if (typeof args[0] === 'boolean') { + deep = args[0]; + target = args[1] || {}; + i = 2; + } + else if (typeof args[0] !== 'object' && typeof args[0] !== 'function' || args[0] == null) { + target = {}; + } + else { + target = args[0]; + } + for (; i < length; ++i) { + const options = args[i]; + if (options != null) { + for (const name in options) { + const src = target[name]; + const copy = options[name]; + if (target === copy) + continue; + let copyIsArray = false; + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + let clone; + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } + else { + clone = src && isPlainObject(src) ? src : {}; + } + target[name] = extend(deep, clone, copy); + } + else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + return target; +} + +const helper = { + isDefined(x) { + return x !== null && x !== undefined; + }, + last(array) { + return array.length > 0 ? array[array.length - 1] : null; + }, + pick(object, keys) { + return keys.reduce((prev, key) => { + prev[key] = object[key]; + return prev; + }, {}); + }, + sum(array, accessor) { + return array.map(accessor).reduce((prev, current) => prev + current, 0); + }, + extend, +}; + +/* +This file is modified from https://github.com/shinout/SortedList + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +class SortedList extends Array { + static create(val1, val2) { + return new SortedList(val1, val2); + } + constructor(arr, options) { + super(); + Object.setPrototypeOf(this, SortedList.prototype); + let resolvedArr = null; + let resolvedOptions = {}; + if (Array.isArray(arr)) { + resolvedArr = arr; + } + else if (arr && typeof arr === 'object') { + resolvedOptions = arr; + } + if (options) + resolvedOptions = options; + this._filter = typeof resolvedOptions.filter === 'function' + ? resolvedOptions.filter + : () => true; + if (typeof resolvedOptions.compare === 'function') { + this._compare = resolvedOptions.compare; + } + else if (typeof resolvedOptions.compare === 'string' && + SortedList.compares[resolvedOptions.compare]) { + this._compare = SortedList.compares[resolvedOptions.compare]; + } + else { + this._compare = SortedList.compares.string; + } + this._unique = !!resolvedOptions.unique; + if (resolvedArr) { + if (resolvedOptions.resume) { + resolvedArr.forEach((v) => this.push(v)); + } + else { + this.insert(...resolvedArr); + } + } + } + insertOne(val) { + const pos = this.bsearch(val); + if (this._unique && this.key(val, pos) != null) + return false; + if (!this._filter(val, pos)) + return false; + this.splice(pos + 1, 0, val); + return pos + 1; + } + insert(...vals) { + return vals.map((val) => this.insertOne(val)); + } + remove(pos) { + this.splice(pos, 1); + return this; + } + bsearch(val) { + if (!this.length) + return -1; + let spos = 0; + let epos = this.length; + while (epos - spos > 1) { + const mpos = Math.floor((spos + epos) / 2); + const mval = this[mpos]; + const comp = this._compare(val, mval); + if (comp === 0) + return mpos; + if (comp > 0) + spos = mpos; + else + epos = mpos; + } + return spos === 0 && this._compare(this[0], val) > 0 ? -1 : spos; + } + key(val, bsResult) { + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + if (pos === -1 || this._compare(this[pos], val) < 0) { + return pos + 1 < this.length && this._compare(this[pos + 1], val) === 0 ? pos + 1 : null; + } + while (pos >= 1 && this._compare(this[pos - 1], val) === 0) + pos--; + return pos; + } + searchKeys(val, bsResult) { + const ret = []; + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + while (pos >= 0 && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos--; + } + const len = this.length; + pos = bsResult + 1; + while (pos < len && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos++; + } + return ret.length ? ret : null; + } + unique(createNew) { + if (createNew) { + return this.filter((v, k) => k === 0 || this._compare(this[k - 1], v) !== 0); + } + let total = 0; + this.map((v, k) => { + if (k === 0 || this._compare(this[k - 1], v) !== 0) + return null; + return k - total++; + }).forEach((k) => { + if (k != null) + this.remove(k); + }); + return this; + } + toArray() { + return this.slice(); + } +} +SortedList.compares = { + number(a, b) { + const c = a - b; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + string(a, b) { + return a > b ? 1 : a === b ? 0 : -1; + }, +}; + +/* +This file is modified from https://github.com/shinout/interval-tree + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +function createInterval(data, id, s, e) { + const start = data[s]; + const end = data[e]; + if (typeof start !== 'number' || typeof end !== 'number') { + throw new Error(`start, end must be number. start: ${start}, end: ${end}`); + } + if (start >= end) { + throw new Error(`start must be smaller than end. start: ${start}, end: ${end}`); + } + return { + id, + start, + end, + data, + result(rangeStart, rangeEnd) { + const ret = { id, data }; + if (typeof rangeStart === 'number' && typeof rangeEnd === 'number') { + const left = Math.max(start, rangeStart); + const right = Math.min(end, rangeEnd); + const lapLn = right - left; + ret.rate1 = lapLn / (rangeEnd - rangeStart); + ret.rate2 = lapLn / (end - start); + } + return ret; + }, + }; +} +function createTreeNode(idx) { + return { + idx, + left: undefined, + right: undefined, + starts: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.start - b.start; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + ends: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.end - b.end; + return c < 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + insert(interval) { + this.starts.insertOne(interval); + this.ends.insertOne(interval); + }, + }; +} +function insertNode(tree, node, itvl) { + if (itvl.end < node.idx) { + if (!node.left) { + node.left = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.left, itvl); + } + if (node.idx < itvl.start) { + if (!node.right) { + node.right = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.right, itvl); + } + node.insert(itvl); +} +function pointSearch(node, idx, arr) { + if (!node) + return; + if (idx < node.idx) { + node.starts.every((itvl) => { + const bool = itvl.start <= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.left, idx, arr); + } + else if (idx > node.idx) { + node.ends.every((itvl) => { + const bool = itvl.end >= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.right, idx, arr); + } + else { + node.starts.forEach((itvl) => arr.push(itvl.result())); + } +} +class IntervalTree { + constructor(center, options = {}) { + var _a, _b; + this.startKey = (_a = options.startKey) !== null && _a !== void 0 ? _a : 0; + this.endKey = (_b = options.endKey) !== null && _b !== void 0 ? _b : 1; + this.intervalHash = {}; + this.pointTree = new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a[0] - b[0]; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }); + this._autoIncrement = 0; + if (!center || typeof center !== 'number') { + throw new Error('you must specify center index as the 2nd argument.'); + } + this.root = createTreeNode(center); + } + add(data, id) { + if (id !== undefined && this.intervalHash[id]) { + throw new Error(`id ${id} is already registered.`); + } + if (id === undefined) { + while (this.intervalHash[this._autoIncrement]) { + this._autoIncrement++; + } + id = this._autoIncrement; + } + const itvl = createInterval(data, id, this.startKey, this.endKey); + this.pointTree.insertOne([itvl.start, id]); + this.pointTree.insertOne([itvl.end, id]); + this.intervalHash[id] = itvl; + this._autoIncrement++; + insertNode(this, this.root, itvl); + } + search(val1, val2) { + const ret = []; + if (typeof val1 !== 'number') { + throw new Error(`${val1}: invalid input`); + } + if (val2 === undefined) { + pointSearch(this.root, val1, ret); + } + else if (typeof val2 === 'number') { + this._rangeSearch(val1, val2, ret); + } + else { + throw new Error(`${val1},${val2}: invalid input`); + } + return ret; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + remove(_intervalId) { + // not implemented + } + _rangeSearch(start, end, arr) { + if (end - start <= 0) { + throw new Error(`end must be greater than start. start: ${start}, end: ${end}`); + } + const resultHash = {}; + const wholeWraps = []; + pointSearch(this.root, (start + end) >> 1, wholeWraps); + wholeWraps.forEach((result) => { + resultHash[result.id] = true; + }); + let idx1 = this.pointTree.bsearch([start, 0]); + const pointTreeArray = this.pointTree; + while (idx1 >= 0 && pointTreeArray[idx1][0] === start) { + idx1--; + } + const idx2Start = this.pointTree.bsearch([end, 0]); + if (idx2Start >= 0) { + const len = pointTreeArray.length - 1; + let idx2 = idx2Start; + while (idx2 <= len && pointTreeArray[idx2][0] <= end) { + idx2++; + } + pointTreeArray.slice(idx1 + 1, idx2).forEach((point) => { + resultHash[point[1]] = true; + }); + Object.keys(resultHash).forEach((idStr) => { + const id = Number(idStr); + const itvl = this.intervalHash[id]; + arr.push(itvl.result(start, end)); + }); + } + } +} + +const DEFAULT_OPTIONS$2 = { + algorithm: 'overlap', + layerWidth: 1000, + density: 0.75, + nodeSpacing: 3, + stubWidth: 1, +}; +function _Distributor(initOptions) { + const distributor = {}; + let options = helper.extend({}, DEFAULT_OPTIONS$2); + if (initOptions) { + options = helper.extend(options, initOptions); + } + distributor.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + return distributor; + }; + distributor.computeRequiredWidth = function (nodes) { + var _a; + return helper.sum(nodes, (d) => { var _a; return d.width + ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); }) - ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); + }; + distributor.maxWidthPerLayer = function () { + var _a, _b; + return ((_a = options.density) !== null && _a !== void 0 ? _a : 0.75) * ((_b = options.layerWidth) !== null && _b !== void 0 ? _b : 1000); + }; + distributor.needToSplit = function (nodes) { + return distributor.estimateRequiredLayers(nodes) > 1; + }; + distributor.estimateRequiredLayers = function (nodes) { + return options.layerWidth + ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) + : 1; + }; + const algorithms = { + simple(nodes) { + const numLayers = distributor.estimateRequiredLayers(nodes); + const layers = []; + for (let i = 0; i < numLayers; i++) + layers.push([]); + nodes.forEach((node, i) => { + var _a; + const mod = i % numLayers; + layers[mod].push(node); + let stub = node; + for (let j = mod - 1; j >= 0; j--) { + stub = stub.createStub((_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1); + layers[j].push(stub); + } + }); + return layers; + }, + roundRobin(_nodes) { + return []; + }, + overlap(nodes) { + var _a, _b, _c; + const layers = []; + const maxWidth = distributor.maxWidthPerLayer(); + let puntedNodes = nodes.concat(); + let puntedWidth = distributor.computeRequiredWidth(puntedNodes); + while (puntedWidth > maxWidth) { + distributor.countIdealOverlaps(puntedNodes); + let nodesInCurrentLayer = puntedNodes.concat(); + let currentlayerWidth = puntedWidth; + puntedNodes = []; + while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { + nodesInCurrentLayer.sort((a, b) => { var _a, _b; return ((_a = b.overlapCount) !== null && _a !== void 0 ? _a : 0) - ((_b = a.overlapCount) !== null && _b !== void 0 ? _b : 0); }); + const first = nodesInCurrentLayer.shift(); + currentlayerWidth -= first.width; + currentlayerWidth += (_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1; + ((_b = first.overlaps) !== null && _b !== void 0 ? _b : []).forEach((node) => { + var _a; + node.overlapCount = ((_a = node.overlapCount) !== null && _a !== void 0 ? _a : 0) - 1; + }); + puntedNodes.push(first); + } + layers.push(nodesInCurrentLayer); + puntedWidth = distributor.computeRequiredWidth(puntedNodes); + } + if (puntedNodes.length > 0) + layers.push(puntedNodes); + for (let i = layers.length - 1; i >= 1; i--) { + const layer = layers[i]; + for (let k = 0; k < layer.length; k++) { + const node = layer[k]; + if (node.isStub()) + continue; + let stub = node; + for (let j = i - 1; j >= 0; j--) { + stub = stub.createStub((_c = options.stubWidth) !== null && _c !== void 0 ? _c : 1); + layers[j].push(stub); + } + } + } + return layers; + }, + }; + distributor.countIdealOverlaps = function (nodes) { + var _a; + const iTree = new IntervalTree(((_a = options.layerWidth) !== null && _a !== void 0 ? _a : 1000) / 2); + nodes.forEach((node) => { + iTree.add([node.idealLeft(), node.idealRight(), node]); + }); + nodes.forEach((node) => { + const overlaps = iTree.search(node.idealLeft(), node.idealRight()); + node.overlaps = overlaps.map((x) => x.data[2]); + node.overlapCount = overlaps.length; + }); + return nodes; + }; + distributor.distribute = function (nodes) { + if (!nodes || nodes.length === 0) + return []; + const algo = options.algorithm; + if (algo === 'none' || !helper.isDefined(algo)) + return [nodes]; + if (!distributor.needToSplit(nodes)) + return [nodes]; + const sortedNodes = nodes.concat().sort((a, b) => a.idealPos - b.idealPos); + if (typeof algo === 'function') { + return algo(sortedNodes, options); + } + else if (typeof algo === 'string' && Object.prototype.hasOwnProperty.call(algorithms, algo)) { + return algorithms[algo](sortedNodes); + } + else { + throw new Error('Unknown algorithm: ' + algo); + } + }; + return distributor; +} +const Distributor = _Distributor; +Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS$2; + +/* +This file is adapted from https://github.com/tgdwyer/WebCola/blob/master/src/vpsc.ts +and modified slightly. + +The MIT License (MIT) +Copyright (c) 2013 Tim Dwyer +*/ +class PositionStats { + constructor(scale) { + this.scale = scale; + this.AB = 0; + this.AD = 0; + this.A2 = 0; + } + addVariable(v) { + const ai = this.scale / v.scale; + const bi = v.offset / v.scale; + const wi = v.weight; + this.AB += wi * ai * bi; + this.AD += wi * ai * v.desiredPosition; + this.A2 += wi * ai * ai; + } + getPosn() { + return (this.AD - this.AB) / this.A2; + } +} +class Constraint { + constructor(left, right, gap, equality = false) { + this.left = left; + this.right = right; + this.gap = gap; + this.equality = equality; + this.active = false; + this.unsatisfiable = false; + } + slack() { + return this.unsatisfiable + ? Number.MAX_VALUE + : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); + } +} +class Variable { + constructor(desiredPosition, weight = 1, scale = 1) { + this.desiredPosition = desiredPosition; + this.weight = weight; + this.scale = scale; + this.offset = 0; + this.cIn = []; + this.cOut = []; + } + dfdv() { + return 2.0 * this.weight * (this.position() - this.desiredPosition); + } + position() { + return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; + } + visitNeighbours(prev, f) { + const ff = (c, next) => { + if (c.active && prev !== next) + f(c, next); + }; + this.cOut.forEach((c) => ff(c, c.right)); + this.cIn.forEach((c) => ff(c, c.left)); + } +} +class Block { + constructor(v) { + this.vars = []; + v.offset = 0; + this.ps = new PositionStats(v.scale); + this.posn = 0; + this.addVariable(v); + } + addVariable(v) { + v.block = this; + this.vars.push(v); + this.ps.addVariable(v); + this.posn = this.ps.getPosn(); + } + updateWeightedPosition() { + this.ps.AB = this.ps.AD = this.ps.A2 = 0; + for (let i = 0, n = this.vars.length; i < n; ++i) { + this.ps.addVariable(this.vars[i]); + } + this.posn = this.ps.getPosn(); + } + compute_lm(v, u, postAction) { + let dfdv = v.dfdv(); + v.visitNeighbours(u, (c, next) => { + const _dfdv = this.compute_lm(next, v, postAction); + if (next === c.right) { + dfdv += _dfdv * c.left.scale; + c.lm = _dfdv; + } + else { + dfdv += _dfdv * c.right.scale; + c.lm = -_dfdv; + } + postAction(c); + }); + return dfdv / v.scale; + } + populateSplitBlock(v, prev) { + v.visitNeighbours(prev, (c, next) => { + next.offset = v.offset + (next === c.right ? c.gap : -c.gap); + this.addVariable(next); + this.populateSplitBlock(next, v); + }); + } + traverse(visit, acc, v = this.vars[0], prev = null) { + v.visitNeighbours(prev, (c, next) => { + acc.push(visit(c)); + this.traverse(visit, acc, next, v); + }); + } + findMinLM() { + let m = null; + this.compute_lm(this.vars[0], null, (c) => { + if (!c.equality && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findMinLMBetween(lv, rv) { + this.compute_lm(lv, null, () => undefined); + let m = null; + this.findPath(lv, null, rv, (c, next) => { + if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findPath(v, prev, to, visit) { + let endFound = false; + v.visitNeighbours(prev, (c, next) => { + if (!endFound && (next === to || this.findPath(next, v, to, visit))) { + endFound = true; + visit(c, next); + } + }); + return endFound; + } + isActiveDirectedPathBetween(u, v) { + if (u === v) + return true; + let i = u.cOut.length; + while (i--) { + const c = u.cOut[i]; + if (c.active && this.isActiveDirectedPathBetween(c.right, v)) + return true; + } + return false; + } + static split(c) { + c.active = false; + return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; + } + static createSplitBlock(startVar) { + const b = new Block(startVar); + b.populateSplitBlock(startVar, null); + return b; + } + splitBetween(vl, vr) { + const c = this.findMinLMBetween(vl, vr); + if (c !== null) { + const bs = Block.split(c); + return { constraint: c, lb: bs[0], rb: bs[1] }; + } + return null; + } + mergeAcross(b, c, dist) { + c.active = true; + for (let i = 0, n = b.vars.length; i < n; ++i) { + const v = b.vars[i]; + v.offset += dist; + this.addVariable(v); + } + this.posn = this.ps.getPosn(); + } + cost() { + let sum = 0; + let i = this.vars.length; + while (i--) { + const v = this.vars[i]; + const d = v.position() - v.desiredPosition; + sum += d * d * v.weight; + } + return sum; + } +} +class Blocks { + constructor(vs) { + this.vs = vs; + const n = vs.length; + this.list = new Array(n); + let i = n; + while (i--) { + const b = new Block(vs[i]); + this.list[i] = b; + b.blockInd = i; + } + } + cost() { + let sum = 0; + let i = this.list.length; + while (i--) + sum += this.list[i].cost(); + return sum; + } + insert(b) { + b.blockInd = this.list.length; + this.list.push(b); + } + remove(b) { + const last = this.list.length - 1; + const swapBlock = this.list[last]; + this.list.length = last; + if (b !== swapBlock) { + this.list[b.blockInd] = swapBlock; + swapBlock.blockInd = b.blockInd; + } + } + merge(c) { + const l = c.left.block; + const r = c.right.block; + const dist = c.right.offset - c.left.offset - c.gap; + if (l.vars.length < r.vars.length) { + r.mergeAcross(l, c, dist); + this.remove(l); + } + else { + l.mergeAcross(r, c, -dist); + this.remove(r); + } + } + forEach(f) { + this.list.forEach(f); + } + updateBlockPositions() { + this.list.forEach((b) => b.updateWeightedPosition()); + } + split(inactive) { + this.updateBlockPositions(); + this.list.forEach((b) => { + const v = b.findMinLM(); + if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { + const origBlock = v.left.block; + Block.split(v).forEach((nb) => this.insert(nb)); + this.remove(origBlock); + inactive.push(v); + } + }); + } +} +class Solver { + constructor(vs, cs) { + this.vs = vs; + this.cs = cs; + vs.forEach((v) => { + v.cIn = []; + v.cOut = []; + }); + cs.forEach((c) => { + c.left.cOut.push(c); + c.right.cIn.push(c); + }); + this.inactive = cs.map((c) => { c.active = false; return c; }); + this.bs = null; + } + cost() { + return this.bs.cost(); + } + setStartingPositions(ps) { + this.inactive = this.cs.map((c) => { c.active = false; return c; }); + this.bs = new Blocks(this.vs); + this.bs.forEach((b, i) => { b.posn = ps[i]; }); + } + setDesiredPositions(ps) { + this.vs.forEach((v, i) => { v.desiredPosition = ps[i]; }); + } + mostViolated() { + let minSlack = Number.MAX_VALUE; + let v = null; + const l = this.inactive; + const n = l.length; + let deletePoint = n; + for (let i = 0; i < n; ++i) { + const c = l[i]; + if (c.unsatisfiable) + continue; + const slack = c.slack(); + if (c.equality || slack < minSlack) { + minSlack = slack; + v = c; + deletePoint = i; + if (c.equality) + break; + } + } + if (deletePoint !== n && + v !== null && + ((minSlack < Solver.ZERO_UPPERBOUND && !v.active) || v.equality)) { + l[deletePoint] = l[n - 1]; + l.length = n - 1; + } + return v; + } + satisfy() { + if (this.bs == null) { + this.bs = new Blocks(this.vs); + } + this.bs.split(this.inactive); + let v; + while ((v = this.mostViolated()) !== null && + (v.equality || (v.slack() < Solver.ZERO_UPPERBOUND && !v.active))) { + const lb = v.left.block; + const rb = v.right.block; + if (lb !== rb) { + this.bs.merge(v); + } + else { + if (lb.isActiveDirectedPathBetween(v.right, v.left)) { + v.unsatisfiable = true; + continue; + } + const split = lb.splitBetween(v.left, v.right); + if (split !== null) { + this.bs.insert(split.lb); + this.bs.insert(split.rb); + this.bs.remove(lb); + this.inactive.push(split.constraint); + } + else { + v.unsatisfiable = true; + continue; + } + if (v.slack() >= 0) { + this.inactive.push(v); + } + else { + this.bs.merge(v); + } + } + } + } + solve() { + this.satisfy(); + let lastcost = Number.MAX_VALUE; + let cost = this.bs.cost(); + while (Math.abs(lastcost - cost) > 0.0001) { + this.satisfy(); + lastcost = cost; + cost = this.bs.cost(); + } + return cost; + } +} +Solver.LAGRANGIAN_TOLERANCE = -1e-4; +Solver.ZERO_UPPERBOUND = -1e-10; + +const DEFAULT_OPTIONS$1 = { + lineSpacing: 2, + nodeSpacing: 3, + minPos: 0, + maxPos: null, +}; +function nodeToVariable(node) { + var _a; + const v = new Variable((_a = node.targetPos) !== null && _a !== void 0 ? _a : node.idealPos); + v['node'] = node; + return v; +} +function removeOverlap(nodes, options) { + if (nodes.length > 0) { + const opts = helper.extend({}, DEFAULT_OPTIONS$1, (options !== null && options !== void 0 ? options : {})); + nodes.forEach((node, index) => { + node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; + node.index = index; + }); + const variables = nodes + .concat() + .sort((a, b) => { + var _a, _b, _c, _d; + const diff = ((_a = a.targetPos) !== null && _a !== void 0 ? _a : 0) - ((_b = b.targetPos) !== null && _b !== void 0 ? _b : 0); + if (diff !== 0) + return diff; + const diff2 = (a.isStub() ? 1 : 0) - (b.isStub() ? 1 : 0); + if (diff2 !== 0) + return diff2; + return ((_c = a.index) !== null && _c !== void 0 ? _c : 0) - ((_d = b.index) !== null && _d !== void 0 ? _d : 0); + }) + .map(nodeToVariable); + const constraints = []; + for (let i = 1; i < variables.length; i++) { + const v1 = variables[i - 1]; + const v2 = variables[i]; + const n1 = v1['node']; + const n2 = v2['node']; + let gap; + if (n1.isStub() && n2.isStub()) { + gap = (n1.width + n2.width) / 2 + opts.lineSpacing; + } + else { + gap = (n1.width + n2.width) / 2 + opts.nodeSpacing; + } + constraints.push(new Constraint(v1, v2, gap)); + } + if (helper.isDefined(opts.minPos) && opts.minPos !== null) { + const leftWall = new Variable(opts.minPos, 1e10); + const v = variables[0]; + const vNode = v['node']; + constraints.push(new Constraint(leftWall, v, vNode.width / 2)); + variables.unshift(leftWall); + } + if (helper.isDefined(opts.maxPos) && opts.maxPos !== null) { + const rightWall = new Variable(opts.maxPos, 1e10); + const lastv = helper.last(variables); + const lastNode = lastv['node']; + constraints.push(new Constraint(lastv, rightWall, lastNode ? lastNode.width / 2 : 0)); + variables.push(rightWall); + } + new Solver(variables, constraints).solve(); + variables + .filter((v) => !!v['node']) + .forEach((v) => { + v['node'].currentPos = Math.round(v.position()); + }); + } + return nodes; +} +removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS$1; + +const DEFAULT_OPTIONS = { + nodeSpacing: 3, + minPos: 0, + maxPos: null, + algorithm: 'overlap', + removeOverlap: true, + density: 0.85, + stubWidth: 1, + lineSpacing: 2, +}; +function _Force(_options) { + const force = {}; + let options = { ...DEFAULT_OPTIONS }; + const distributor = Distributor(); + let nodes = []; + let layers = null; + force.nodes = function (x) { + if (!arguments.length) + return nodes; + nodes = x; + layers = [x.concat()]; + return force; + }; + force.getLayers = function () { + return layers; + }; + force.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + const disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); + if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { + disOptions.layerWidth = options.maxPos - options.minPos; + } + else { + disOptions.layerWidth = null; + } + distributor.options(disOptions); + return force; + }; + force.options(_options !== null && _options !== void 0 ? _options : {}); + force.compute = function () { + const overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); + nodes.forEach((node) => node.removeStub()); + layers = distributor.distribute(nodes); + layers.forEach((layerNodes, layerIndex) => { + layerNodes.forEach((node) => { + node.layerIndex = layerIndex; + }); + if (options.removeOverlap) { + removeOverlap(layerNodes, overlapOptions); + } + }); + return force; + }; + force.start = function () { + console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); + }; + return force; +} +const Force = _Force; +Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; + +function lineTo(point) { + return 'L ' + point.join(' '); +} +function moveTo(point) { + return 'M ' + point.join(' '); +} +function curveTo(c1, c2, point2) { + return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); +} +function vCurveBetween(point1, point2) { + const midY = (point1[1] + point2[1]) / 2; + return curveTo([point1[0], midY], [point2[0], midY], point2); +} +function hCurveBetween(point1, point2) { + const midX = (point1[0] + point2[0]) / 2; + return curveTo([midX, point1[1]], [midX, point2[1]], point2); +} +class Renderer { + constructor(options) { + this.options = helper.extend({ layerGap: 60, nodeHeight: 10, direction: 'down' }, (options !== null && options !== void 0 ? options : {})); + } + getWaypoints(node) { + const { nodeHeight, layerGap, direction } = this.options; + const hops = node.getPathFromRoot(); + const gap = nodeHeight + layerGap; + if (direction === 'left') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1) * -1; + return [ + [xPos + nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'right') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1); + return [ + [xPos - nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'up') { + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1) * -1; + return [ + [hop.currentPos, yPos + nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + else { + // down + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1); + return [ + [hop.currentPos, yPos - nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + } + layout(nodes) { + const { layerGap, nodeHeight, direction } = this.options; + const gap = layerGap + nodeHeight; + switch (direction) { + case 'left': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = -pos - nodeHeight; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'right': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = pos; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'up': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = -pos - nodeHeight; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + default: + case 'down': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = pos; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + } + return nodes; + } + generatePath(node) { + const { direction } = this.options; + const waypoints = this.getWaypoints(node); + const steps = [moveTo(waypoints[0][0])]; + if (direction === 'left' || direction === 'right') { + waypoints.reduce((prev, current, level) => { + steps.push(hCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + else { + waypoints.reduce((prev, current, level) => { + steps.push(vCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + return steps.join(' '); + } +} +Renderer.lineTo = lineTo; +Renderer.moveTo = moveTo; +Renderer.curveTo = curveTo; +Renderer.vCurveBetween = vCurveBetween; +Renderer.hCurveBetween = hCurveBetween; + +function toLayers(nodes) { + if (nodes.length === 0) + return nodes; + return Array.isArray(nodes[0]) ? nodes : [nodes]; +} +function denominator(layers) { + return helper.sum(layers, (layer) => layer.length); +} +function denominatorWithoutStubs(layers) { + return helper.sum(layers, (layer) => layer.filter((l) => !l.isStub()).length); +} +const metrics = { + displacement(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.displacement())))) / denominatorWithoutStubs(layers)); + }, + pathLength(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.getPathToRootLength())))) / denominatorWithoutStubs(layers)); + }, + overflowSpace(nodes, minPos, maxPos) { + if (nodes.length === 0 || (!helper.isDefined(minPos) && !helper.isDefined(maxPos))) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => helper.sum(layer, (node) => { + const l = node.currentLeft(); + const r = node.currentRight(); + if (helper.isDefined(minPos) && minPos !== undefined && minPos !== null) { + if (r <= minPos) + return node.width; + else if (l < minPos) + return minPos - l; + } + if (helper.isDefined(maxPos) && maxPos !== undefined && maxPos !== null) { + if (l >= maxPos) + return node.width; + else if (r > maxPos) + return r - maxPos; + } + return 0; + })); + }, + overDensitySpace(nodes, density, layerWidth, nodeSpacing = 0) { + if (nodes.length === 0 || !helper.isDefined(density) || !helper.isDefined(layerWidth)) + return 0; + const limit = density * layerWidth; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + const width = helper.sum(layer, (node) => node.width + nodeSpacing) - nodeSpacing; + return width <= limit ? 0 : width - limit; + }); + }, + overlapCount(nodes, buffer) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + if (layer[i].overlapWithNode(layer[j], buffer)) + count++; + } + } + return count; + }); + }, + overlapSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + const distance = layer[i].distanceFrom(layer[j]); + count += distance < 0 ? Math.abs(distance) : 0; + } + } + return count; + }) / denominator(layers)); + }, + weightedAllocation(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * layer.filter((l) => !l.isStub()).length); + }, + weightedAllocatedSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * helper.sum(layer, (d) => d.width)); + }, +}; + +const util = { + generateNodes(amount, options) { + const nodes = []; + const opts = helper.extend({}, { minWidth: 20, maxWidth: 20, minPos: 0, maxPos: 800 }, (options !== null && options !== void 0 ? options : {})); + const diffPos = opts.maxPos - opts.minPos; + const diffWidth = opts.maxWidth - opts.minWidth; + for (let i = 0; i < amount; i++) { + nodes.push(new LabelNode(Math.floor(Math.random() * diffPos) + opts.minPos, Math.floor(Math.random() * diffWidth) + opts.minWidth)); + } + return nodes; + }, +}; + +exports.Distributor = Distributor; +exports.Force = Force; +exports.Node = LabelNode; +exports.Renderer = Renderer; +exports.metrics = metrics; +exports.util = util; diff --git a/dist/labella.cjs.map b/dist/labella.cjs.map new file mode 100644 index 0000000..43eca89 --- /dev/null +++ b/dist/labella.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"labella.cjs","sources":["../src/core/node.ts","../src/lib/extend.ts","../src/core/helper.ts","../src/lib/sortedList.ts","../src/lib/intervalTree.ts","../src/core/distributor.ts","../src/lib/vpsc.ts","../src/core/removeOverlap.ts","../src/core/force.ts","../src/core/renderer.ts","../src/core/metrics.ts","../src/core/util.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null],"names":["DEFAULT_OPTIONS"],"mappings":"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"} \ No newline at end of file diff --git a/dist/labella.d.ts b/dist/labella.d.ts new file mode 100644 index 0000000..a848e04 --- /dev/null +++ b/dist/labella.d.ts @@ -0,0 +1,1417 @@ +class LabelNode { + constructor(idealPos, width, data) { + this.idealPos = idealPos; + this.currentPos = idealPos; + this.width = width; + this.data = data; + this.layerIndex = 0; + this.parent = null; + this.child = null; + } + /** Returns negative if nodes overlap */ + distanceFrom(node) { + const halfWidth = this.width / 2; + const nodeHalfWidth = node.width / 2; + return (Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - + Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth)); + } + moveToIdealPosition() { + this.currentPos = this.idealPos; + return this; + } + displacement() { + return this.idealPos - this.currentPos; + } + overlapWithNode(node, buffer = 0) { + return this.distanceFrom(node) - buffer < 0; + } + overlapWithPoint(pos) { + const halfWidth = this.width / 2; + return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; + } + positionBefore(node, buffer = 0) { + return node.currentLeft() - this.width / 2 - buffer; + } + positionAfter(node, buffer = 0) { + return node.currentRight() + this.width / 2 + buffer; + } + currentRight() { + return this.currentPos + this.width / 2; + } + currentLeft() { + return this.currentPos - this.width / 2; + } + idealRight() { + return this.idealPos + this.width / 2; + } + idealLeft() { + return this.idealPos - this.width / 2; + } + createStub(width) { + const stub = new LabelNode(this.idealPos, width !== null && width !== void 0 ? width : this.width, this.data); + stub.currentPos = this.currentPos; + stub.child = this; + this.parent = stub; + return stub; + } + removeStub() { + if (this.parent) { + this.parent.child = null; + this.parent = null; + } + return this; + } + isStub() { + return !!this.child; + } + getPathToRoot() { + const path = []; + let current = this; + while (current) { + path.push(current); + current = current.parent; + } + return path; + } + getPathFromRoot() { + return this.getPathToRoot().reverse(); + } + getPathToRootLength() { + let length = 0; + let current = this; + while (current) { + const targetPos = current.parent ? current.parent.currentPos : current.idealPos; + length += Math.abs(current.currentPos - targetPos); + current = current.parent; + } + return length; + } + getRoot() { + let previous = this; + let current = this; + while (current) { + previous = current; + current = current.parent; + } + return previous; + } + getLayerIndex() { + return this.layerIndex; + } + clone() { + const node = new LabelNode(this.idealPos, this.width, this.data); + node.currentPos = this.currentPos; + node.layerIndex = this.layerIndex; + return node; + } +} + +/* +This file is modified from https://github.com/justmoon/node-extend +The MIT License (MIT) + +Copyright (c) 2014 Stefan Thomas +*/ +const hasOwn = Object.prototype.hasOwnProperty; +const toStr = Object.prototype.toString; +function isArray(arr) { + return Array.isArray(arr); +} +function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + const o = obj; + const has_own_constructor = hasOwn.call(o, 'constructor'); + const ctor = o.constructor; + const has_is_property_of_method = ctor && ctor.prototype && hasOwn.call(ctor.prototype, 'isPrototypeOf'); + if (ctor && !has_own_constructor && !has_is_property_of_method) { + return false; + } + let key; + for (key in o) { + // intentionally empty + } + return key === undefined || hasOwn.call(o, key); +} +function extend(...args) { + let target; + let i = 1; + const length = args.length; + let deep = false; + if (typeof args[0] === 'boolean') { + deep = args[0]; + target = args[1] || {}; + i = 2; + } + else if (typeof args[0] !== 'object' && typeof args[0] !== 'function' || args[0] == null) { + target = {}; + } + else { + target = args[0]; + } + for (; i < length; ++i) { + const options = args[i]; + if (options != null) { + for (const name in options) { + const src = target[name]; + const copy = options[name]; + if (target === copy) + continue; + let copyIsArray = false; + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + let clone; + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } + else { + clone = src && isPlainObject(src) ? src : {}; + } + target[name] = extend(deep, clone, copy); + } + else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + return target; +} + +const helper = { + isDefined(x) { + return x !== null && x !== undefined; + }, + last(array) { + return array.length > 0 ? array[array.length - 1] : null; + }, + pick(object, keys) { + return keys.reduce((prev, key) => { + prev[key] = object[key]; + return prev; + }, {}); + }, + sum(array, accessor) { + return array.map(accessor).reduce((prev, current) => prev + current, 0); + }, + extend, +}; + +/* +This file is modified from https://github.com/shinout/SortedList + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +class SortedList extends Array { + static create(val1, val2) { + return new SortedList(val1, val2); + } + constructor(arr, options) { + super(); + Object.setPrototypeOf(this, SortedList.prototype); + let resolvedArr = null; + let resolvedOptions = {}; + if (Array.isArray(arr)) { + resolvedArr = arr; + } + else if (arr && typeof arr === 'object') { + resolvedOptions = arr; + } + if (options) + resolvedOptions = options; + this._filter = typeof resolvedOptions.filter === 'function' + ? resolvedOptions.filter + : () => true; + if (typeof resolvedOptions.compare === 'function') { + this._compare = resolvedOptions.compare; + } + else if (typeof resolvedOptions.compare === 'string' && + SortedList.compares[resolvedOptions.compare]) { + this._compare = SortedList.compares[resolvedOptions.compare]; + } + else { + this._compare = SortedList.compares.string; + } + this._unique = !!resolvedOptions.unique; + if (resolvedArr) { + if (resolvedOptions.resume) { + resolvedArr.forEach((v) => this.push(v)); + } + else { + this.insert(...resolvedArr); + } + } + } + insertOne(val) { + const pos = this.bsearch(val); + if (this._unique && this.key(val, pos) != null) + return false; + if (!this._filter(val, pos)) + return false; + this.splice(pos + 1, 0, val); + return pos + 1; + } + insert(...vals) { + return vals.map((val) => this.insertOne(val)); + } + remove(pos) { + this.splice(pos, 1); + return this; + } + bsearch(val) { + if (!this.length) + return -1; + let spos = 0; + let epos = this.length; + while (epos - spos > 1) { + const mpos = Math.floor((spos + epos) / 2); + const mval = this[mpos]; + const comp = this._compare(val, mval); + if (comp === 0) + return mpos; + if (comp > 0) + spos = mpos; + else + epos = mpos; + } + return spos === 0 && this._compare(this[0], val) > 0 ? -1 : spos; + } + key(val, bsResult) { + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + if (pos === -1 || this._compare(this[pos], val) < 0) { + return pos + 1 < this.length && this._compare(this[pos + 1], val) === 0 ? pos + 1 : null; + } + while (pos >= 1 && this._compare(this[pos - 1], val) === 0) + pos--; + return pos; + } + searchKeys(val, bsResult) { + const ret = []; + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + while (pos >= 0 && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos--; + } + const len = this.length; + pos = bsResult + 1; + while (pos < len && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos++; + } + return ret.length ? ret : null; + } + unique(createNew) { + if (createNew) { + return this.filter((v, k) => k === 0 || this._compare(this[k - 1], v) !== 0); + } + let total = 0; + this.map((v, k) => { + if (k === 0 || this._compare(this[k - 1], v) !== 0) + return null; + return k - total++; + }).forEach((k) => { + if (k != null) + this.remove(k); + }); + return this; + } + toArray() { + return this.slice(); + } +} +SortedList.compares = { + number(a, b) { + const c = a - b; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + string(a, b) { + return a > b ? 1 : a === b ? 0 : -1; + }, +}; + +/* +This file is modified from https://github.com/shinout/interval-tree + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +function createInterval(data, id, s, e) { + const start = data[s]; + const end = data[e]; + if (typeof start !== 'number' || typeof end !== 'number') { + throw new Error(`start, end must be number. start: ${start}, end: ${end}`); + } + if (start >= end) { + throw new Error(`start must be smaller than end. start: ${start}, end: ${end}`); + } + return { + id, + start, + end, + data, + result(rangeStart, rangeEnd) { + const ret = { id, data }; + if (typeof rangeStart === 'number' && typeof rangeEnd === 'number') { + const left = Math.max(start, rangeStart); + const right = Math.min(end, rangeEnd); + const lapLn = right - left; + ret.rate1 = lapLn / (rangeEnd - rangeStart); + ret.rate2 = lapLn / (end - start); + } + return ret; + }, + }; +} +function createTreeNode(idx) { + return { + idx, + left: undefined, + right: undefined, + starts: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.start - b.start; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + ends: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.end - b.end; + return c < 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + insert(interval) { + this.starts.insertOne(interval); + this.ends.insertOne(interval); + }, + }; +} +function insertNode(tree, node, itvl) { + if (itvl.end < node.idx) { + if (!node.left) { + node.left = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.left, itvl); + } + if (node.idx < itvl.start) { + if (!node.right) { + node.right = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.right, itvl); + } + node.insert(itvl); +} +function pointSearch(node, idx, arr) { + if (!node) + return; + if (idx < node.idx) { + node.starts.every((itvl) => { + const bool = itvl.start <= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.left, idx, arr); + } + else if (idx > node.idx) { + node.ends.every((itvl) => { + const bool = itvl.end >= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.right, idx, arr); + } + else { + node.starts.forEach((itvl) => arr.push(itvl.result())); + } +} +class IntervalTree { + constructor(center, options = {}) { + var _a, _b; + this.startKey = (_a = options.startKey) !== null && _a !== void 0 ? _a : 0; + this.endKey = (_b = options.endKey) !== null && _b !== void 0 ? _b : 1; + this.intervalHash = {}; + this.pointTree = new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a[0] - b[0]; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }); + this._autoIncrement = 0; + if (!center || typeof center !== 'number') { + throw new Error('you must specify center index as the 2nd argument.'); + } + this.root = createTreeNode(center); + } + add(data, id) { + if (id !== undefined && this.intervalHash[id]) { + throw new Error(`id ${id} is already registered.`); + } + if (id === undefined) { + while (this.intervalHash[this._autoIncrement]) { + this._autoIncrement++; + } + id = this._autoIncrement; + } + const itvl = createInterval(data, id, this.startKey, this.endKey); + this.pointTree.insertOne([itvl.start, id]); + this.pointTree.insertOne([itvl.end, id]); + this.intervalHash[id] = itvl; + this._autoIncrement++; + insertNode(this, this.root, itvl); + } + search(val1, val2) { + const ret = []; + if (typeof val1 !== 'number') { + throw new Error(`${val1}: invalid input`); + } + if (val2 === undefined) { + pointSearch(this.root, val1, ret); + } + else if (typeof val2 === 'number') { + this._rangeSearch(val1, val2, ret); + } + else { + throw new Error(`${val1},${val2}: invalid input`); + } + return ret; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + remove(_intervalId) { + // not implemented + } + _rangeSearch(start, end, arr) { + if (end - start <= 0) { + throw new Error(`end must be greater than start. start: ${start}, end: ${end}`); + } + const resultHash = {}; + const wholeWraps = []; + pointSearch(this.root, (start + end) >> 1, wholeWraps); + wholeWraps.forEach((result) => { + resultHash[result.id] = true; + }); + let idx1 = this.pointTree.bsearch([start, 0]); + const pointTreeArray = this.pointTree; + while (idx1 >= 0 && pointTreeArray[idx1][0] === start) { + idx1--; + } + const idx2Start = this.pointTree.bsearch([end, 0]); + if (idx2Start >= 0) { + const len = pointTreeArray.length - 1; + let idx2 = idx2Start; + while (idx2 <= len && pointTreeArray[idx2][0] <= end) { + idx2++; + } + pointTreeArray.slice(idx1 + 1, idx2).forEach((point) => { + resultHash[point[1]] = true; + }); + Object.keys(resultHash).forEach((idStr) => { + const id = Number(idStr); + const itvl = this.intervalHash[id]; + arr.push(itvl.result(start, end)); + }); + } + } +} + +const DEFAULT_OPTIONS$2 = { + algorithm: 'overlap', + layerWidth: 1000, + density: 0.75, + nodeSpacing: 3, + stubWidth: 1, +}; +function _Distributor(initOptions) { + const distributor = {}; + let options = helper.extend({}, DEFAULT_OPTIONS$2); + if (initOptions) { + options = helper.extend(options, initOptions); + } + distributor.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + return distributor; + }; + distributor.computeRequiredWidth = function (nodes) { + var _a; + return helper.sum(nodes, (d) => { var _a; return d.width + ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); }) - ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); + }; + distributor.maxWidthPerLayer = function () { + var _a, _b; + return ((_a = options.density) !== null && _a !== void 0 ? _a : 0.75) * ((_b = options.layerWidth) !== null && _b !== void 0 ? _b : 1000); + }; + distributor.needToSplit = function (nodes) { + return distributor.estimateRequiredLayers(nodes) > 1; + }; + distributor.estimateRequiredLayers = function (nodes) { + return options.layerWidth + ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) + : 1; + }; + const algorithms = { + simple(nodes) { + const numLayers = distributor.estimateRequiredLayers(nodes); + const layers = []; + for (let i = 0; i < numLayers; i++) + layers.push([]); + nodes.forEach((node, i) => { + var _a; + const mod = i % numLayers; + layers[mod].push(node); + let stub = node; + for (let j = mod - 1; j >= 0; j--) { + stub = stub.createStub((_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1); + layers[j].push(stub); + } + }); + return layers; + }, + roundRobin(_nodes) { + return []; + }, + overlap(nodes) { + var _a, _b, _c; + const layers = []; + const maxWidth = distributor.maxWidthPerLayer(); + let puntedNodes = nodes.concat(); + let puntedWidth = distributor.computeRequiredWidth(puntedNodes); + while (puntedWidth > maxWidth) { + distributor.countIdealOverlaps(puntedNodes); + let nodesInCurrentLayer = puntedNodes.concat(); + let currentlayerWidth = puntedWidth; + puntedNodes = []; + while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { + nodesInCurrentLayer.sort((a, b) => { var _a, _b; return ((_a = b.overlapCount) !== null && _a !== void 0 ? _a : 0) - ((_b = a.overlapCount) !== null && _b !== void 0 ? _b : 0); }); + const first = nodesInCurrentLayer.shift(); + currentlayerWidth -= first.width; + currentlayerWidth += (_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1; + ((_b = first.overlaps) !== null && _b !== void 0 ? _b : []).forEach((node) => { + var _a; + node.overlapCount = ((_a = node.overlapCount) !== null && _a !== void 0 ? _a : 0) - 1; + }); + puntedNodes.push(first); + } + layers.push(nodesInCurrentLayer); + puntedWidth = distributor.computeRequiredWidth(puntedNodes); + } + if (puntedNodes.length > 0) + layers.push(puntedNodes); + for (let i = layers.length - 1; i >= 1; i--) { + const layer = layers[i]; + for (let k = 0; k < layer.length; k++) { + const node = layer[k]; + if (node.isStub()) + continue; + let stub = node; + for (let j = i - 1; j >= 0; j--) { + stub = stub.createStub((_c = options.stubWidth) !== null && _c !== void 0 ? _c : 1); + layers[j].push(stub); + } + } + } + return layers; + }, + }; + distributor.countIdealOverlaps = function (nodes) { + var _a; + const iTree = new IntervalTree(((_a = options.layerWidth) !== null && _a !== void 0 ? _a : 1000) / 2); + nodes.forEach((node) => { + iTree.add([node.idealLeft(), node.idealRight(), node]); + }); + nodes.forEach((node) => { + const overlaps = iTree.search(node.idealLeft(), node.idealRight()); + node.overlaps = overlaps.map((x) => x.data[2]); + node.overlapCount = overlaps.length; + }); + return nodes; + }; + distributor.distribute = function (nodes) { + if (!nodes || nodes.length === 0) + return []; + const algo = options.algorithm; + if (algo === 'none' || !helper.isDefined(algo)) + return [nodes]; + if (!distributor.needToSplit(nodes)) + return [nodes]; + const sortedNodes = nodes.concat().sort((a, b) => a.idealPos - b.idealPos); + if (typeof algo === 'function') { + return algo(sortedNodes, options); + } + else if (typeof algo === 'string' && Object.prototype.hasOwnProperty.call(algorithms, algo)) { + return algorithms[algo](sortedNodes); + } + else { + throw new Error('Unknown algorithm: ' + algo); + } + }; + return distributor; +} +const Distributor = _Distributor; +Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS$2; + +/* +This file is adapted from https://github.com/tgdwyer/WebCola/blob/master/src/vpsc.ts +and modified slightly. + +The MIT License (MIT) +Copyright (c) 2013 Tim Dwyer +*/ +class PositionStats { + constructor(scale) { + this.scale = scale; + this.AB = 0; + this.AD = 0; + this.A2 = 0; + } + addVariable(v) { + const ai = this.scale / v.scale; + const bi = v.offset / v.scale; + const wi = v.weight; + this.AB += wi * ai * bi; + this.AD += wi * ai * v.desiredPosition; + this.A2 += wi * ai * ai; + } + getPosn() { + return (this.AD - this.AB) / this.A2; + } +} +class Constraint { + constructor(left, right, gap, equality = false) { + this.left = left; + this.right = right; + this.gap = gap; + this.equality = equality; + this.active = false; + this.unsatisfiable = false; + } + slack() { + return this.unsatisfiable + ? Number.MAX_VALUE + : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); + } +} +class Variable { + constructor(desiredPosition, weight = 1, scale = 1) { + this.desiredPosition = desiredPosition; + this.weight = weight; + this.scale = scale; + this.offset = 0; + this.cIn = []; + this.cOut = []; + } + dfdv() { + return 2.0 * this.weight * (this.position() - this.desiredPosition); + } + position() { + return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; + } + visitNeighbours(prev, f) { + const ff = (c, next) => { + if (c.active && prev !== next) + f(c, next); + }; + this.cOut.forEach((c) => ff(c, c.right)); + this.cIn.forEach((c) => ff(c, c.left)); + } +} +class Block { + constructor(v) { + this.vars = []; + v.offset = 0; + this.ps = new PositionStats(v.scale); + this.posn = 0; + this.addVariable(v); + } + addVariable(v) { + v.block = this; + this.vars.push(v); + this.ps.addVariable(v); + this.posn = this.ps.getPosn(); + } + updateWeightedPosition() { + this.ps.AB = this.ps.AD = this.ps.A2 = 0; + for (let i = 0, n = this.vars.length; i < n; ++i) { + this.ps.addVariable(this.vars[i]); + } + this.posn = this.ps.getPosn(); + } + compute_lm(v, u, postAction) { + let dfdv = v.dfdv(); + v.visitNeighbours(u, (c, next) => { + const _dfdv = this.compute_lm(next, v, postAction); + if (next === c.right) { + dfdv += _dfdv * c.left.scale; + c.lm = _dfdv; + } + else { + dfdv += _dfdv * c.right.scale; + c.lm = -_dfdv; + } + postAction(c); + }); + return dfdv / v.scale; + } + populateSplitBlock(v, prev) { + v.visitNeighbours(prev, (c, next) => { + next.offset = v.offset + (next === c.right ? c.gap : -c.gap); + this.addVariable(next); + this.populateSplitBlock(next, v); + }); + } + traverse(visit, acc, v = this.vars[0], prev = null) { + v.visitNeighbours(prev, (c, next) => { + acc.push(visit(c)); + this.traverse(visit, acc, next, v); + }); + } + findMinLM() { + let m = null; + this.compute_lm(this.vars[0], null, (c) => { + if (!c.equality && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findMinLMBetween(lv, rv) { + this.compute_lm(lv, null, () => undefined); + let m = null; + this.findPath(lv, null, rv, (c, next) => { + if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findPath(v, prev, to, visit) { + let endFound = false; + v.visitNeighbours(prev, (c, next) => { + if (!endFound && (next === to || this.findPath(next, v, to, visit))) { + endFound = true; + visit(c, next); + } + }); + return endFound; + } + isActiveDirectedPathBetween(u, v) { + if (u === v) + return true; + let i = u.cOut.length; + while (i--) { + const c = u.cOut[i]; + if (c.active && this.isActiveDirectedPathBetween(c.right, v)) + return true; + } + return false; + } + static split(c) { + c.active = false; + return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; + } + static createSplitBlock(startVar) { + const b = new Block(startVar); + b.populateSplitBlock(startVar, null); + return b; + } + splitBetween(vl, vr) { + const c = this.findMinLMBetween(vl, vr); + if (c !== null) { + const bs = Block.split(c); + return { constraint: c, lb: bs[0], rb: bs[1] }; + } + return null; + } + mergeAcross(b, c, dist) { + c.active = true; + for (let i = 0, n = b.vars.length; i < n; ++i) { + const v = b.vars[i]; + v.offset += dist; + this.addVariable(v); + } + this.posn = this.ps.getPosn(); + } + cost() { + let sum = 0; + let i = this.vars.length; + while (i--) { + const v = this.vars[i]; + const d = v.position() - v.desiredPosition; + sum += d * d * v.weight; + } + return sum; + } +} +class Blocks { + constructor(vs) { + this.vs = vs; + const n = vs.length; + this.list = new Array(n); + let i = n; + while (i--) { + const b = new Block(vs[i]); + this.list[i] = b; + b.blockInd = i; + } + } + cost() { + let sum = 0; + let i = this.list.length; + while (i--) + sum += this.list[i].cost(); + return sum; + } + insert(b) { + b.blockInd = this.list.length; + this.list.push(b); + } + remove(b) { + const last = this.list.length - 1; + const swapBlock = this.list[last]; + this.list.length = last; + if (b !== swapBlock) { + this.list[b.blockInd] = swapBlock; + swapBlock.blockInd = b.blockInd; + } + } + merge(c) { + const l = c.left.block; + const r = c.right.block; + const dist = c.right.offset - c.left.offset - c.gap; + if (l.vars.length < r.vars.length) { + r.mergeAcross(l, c, dist); + this.remove(l); + } + else { + l.mergeAcross(r, c, -dist); + this.remove(r); + } + } + forEach(f) { + this.list.forEach(f); + } + updateBlockPositions() { + this.list.forEach((b) => b.updateWeightedPosition()); + } + split(inactive) { + this.updateBlockPositions(); + this.list.forEach((b) => { + const v = b.findMinLM(); + if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { + const origBlock = v.left.block; + Block.split(v).forEach((nb) => this.insert(nb)); + this.remove(origBlock); + inactive.push(v); + } + }); + } +} +class Solver { + constructor(vs, cs) { + this.vs = vs; + this.cs = cs; + vs.forEach((v) => { + v.cIn = []; + v.cOut = []; + }); + cs.forEach((c) => { + c.left.cOut.push(c); + c.right.cIn.push(c); + }); + this.inactive = cs.map((c) => { c.active = false; return c; }); + this.bs = null; + } + cost() { + return this.bs.cost(); + } + setStartingPositions(ps) { + this.inactive = this.cs.map((c) => { c.active = false; return c; }); + this.bs = new Blocks(this.vs); + this.bs.forEach((b, i) => { b.posn = ps[i]; }); + } + setDesiredPositions(ps) { + this.vs.forEach((v, i) => { v.desiredPosition = ps[i]; }); + } + mostViolated() { + let minSlack = Number.MAX_VALUE; + let v = null; + const l = this.inactive; + const n = l.length; + let deletePoint = n; + for (let i = 0; i < n; ++i) { + const c = l[i]; + if (c.unsatisfiable) + continue; + const slack = c.slack(); + if (c.equality || slack < minSlack) { + minSlack = slack; + v = c; + deletePoint = i; + if (c.equality) + break; + } + } + if (deletePoint !== n && + v !== null && + ((minSlack < Solver.ZERO_UPPERBOUND && !v.active) || v.equality)) { + l[deletePoint] = l[n - 1]; + l.length = n - 1; + } + return v; + } + satisfy() { + if (this.bs == null) { + this.bs = new Blocks(this.vs); + } + this.bs.split(this.inactive); + let v; + while ((v = this.mostViolated()) !== null && + (v.equality || (v.slack() < Solver.ZERO_UPPERBOUND && !v.active))) { + const lb = v.left.block; + const rb = v.right.block; + if (lb !== rb) { + this.bs.merge(v); + } + else { + if (lb.isActiveDirectedPathBetween(v.right, v.left)) { + v.unsatisfiable = true; + continue; + } + const split = lb.splitBetween(v.left, v.right); + if (split !== null) { + this.bs.insert(split.lb); + this.bs.insert(split.rb); + this.bs.remove(lb); + this.inactive.push(split.constraint); + } + else { + v.unsatisfiable = true; + continue; + } + if (v.slack() >= 0) { + this.inactive.push(v); + } + else { + this.bs.merge(v); + } + } + } + } + solve() { + this.satisfy(); + let lastcost = Number.MAX_VALUE; + let cost = this.bs.cost(); + while (Math.abs(lastcost - cost) > 0.0001) { + this.satisfy(); + lastcost = cost; + cost = this.bs.cost(); + } + return cost; + } +} +Solver.LAGRANGIAN_TOLERANCE = -1e-4; +Solver.ZERO_UPPERBOUND = -1e-10; + +const DEFAULT_OPTIONS$1 = { + lineSpacing: 2, + nodeSpacing: 3, + minPos: 0, + maxPos: null, +}; +function nodeToVariable(node) { + var _a; + const v = new Variable((_a = node.targetPos) !== null && _a !== void 0 ? _a : node.idealPos); + v['node'] = node; + return v; +} +function removeOverlap(nodes, options) { + if (nodes.length > 0) { + const opts = helper.extend({}, DEFAULT_OPTIONS$1, (options !== null && options !== void 0 ? options : {})); + nodes.forEach((node, index) => { + node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; + node.index = index; + }); + const variables = nodes + .concat() + .sort((a, b) => { + var _a, _b, _c, _d; + const diff = ((_a = a.targetPos) !== null && _a !== void 0 ? _a : 0) - ((_b = b.targetPos) !== null && _b !== void 0 ? _b : 0); + if (diff !== 0) + return diff; + const diff2 = (a.isStub() ? 1 : 0) - (b.isStub() ? 1 : 0); + if (diff2 !== 0) + return diff2; + return ((_c = a.index) !== null && _c !== void 0 ? _c : 0) - ((_d = b.index) !== null && _d !== void 0 ? _d : 0); + }) + .map(nodeToVariable); + const constraints = []; + for (let i = 1; i < variables.length; i++) { + const v1 = variables[i - 1]; + const v2 = variables[i]; + const n1 = v1['node']; + const n2 = v2['node']; + let gap; + if (n1.isStub() && n2.isStub()) { + gap = (n1.width + n2.width) / 2 + opts.lineSpacing; + } + else { + gap = (n1.width + n2.width) / 2 + opts.nodeSpacing; + } + constraints.push(new Constraint(v1, v2, gap)); + } + if (helper.isDefined(opts.minPos) && opts.minPos !== null) { + const leftWall = new Variable(opts.minPos, 1e10); + const v = variables[0]; + const vNode = v['node']; + constraints.push(new Constraint(leftWall, v, vNode.width / 2)); + variables.unshift(leftWall); + } + if (helper.isDefined(opts.maxPos) && opts.maxPos !== null) { + const rightWall = new Variable(opts.maxPos, 1e10); + const lastv = helper.last(variables); + const lastNode = lastv['node']; + constraints.push(new Constraint(lastv, rightWall, lastNode ? lastNode.width / 2 : 0)); + variables.push(rightWall); + } + new Solver(variables, constraints).solve(); + variables + .filter((v) => !!v['node']) + .forEach((v) => { + v['node'].currentPos = Math.round(v.position()); + }); + } + return nodes; +} +removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS$1; + +const DEFAULT_OPTIONS = { + nodeSpacing: 3, + minPos: 0, + maxPos: null, + algorithm: 'overlap', + removeOverlap: true, + density: 0.85, + stubWidth: 1, + lineSpacing: 2, +}; +function _Force(_options) { + const force = {}; + let options = { ...DEFAULT_OPTIONS }; + const distributor = Distributor(); + let nodes = []; + let layers = null; + force.nodes = function (x) { + if (!arguments.length) + return nodes; + nodes = x; + layers = [x.concat()]; + return force; + }; + force.getLayers = function () { + return layers; + }; + force.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + const disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); + if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { + disOptions.layerWidth = options.maxPos - options.minPos; + } + else { + disOptions.layerWidth = null; + } + distributor.options(disOptions); + return force; + }; + force.options(_options !== null && _options !== void 0 ? _options : {}); + force.compute = function () { + const overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); + nodes.forEach((node) => node.removeStub()); + layers = distributor.distribute(nodes); + layers.forEach((layerNodes, layerIndex) => { + layerNodes.forEach((node) => { + node.layerIndex = layerIndex; + }); + if (options.removeOverlap) { + removeOverlap(layerNodes, overlapOptions); + } + }); + return force; + }; + force.start = function () { + console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); + }; + return force; +} +const Force = _Force; +Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; + +function lineTo(point) { + return 'L ' + point.join(' '); +} +function moveTo(point) { + return 'M ' + point.join(' '); +} +function curveTo(c1, c2, point2) { + return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); +} +function vCurveBetween(point1, point2) { + const midY = (point1[1] + point2[1]) / 2; + return curveTo([point1[0], midY], [point2[0], midY], point2); +} +function hCurveBetween(point1, point2) { + const midX = (point1[0] + point2[0]) / 2; + return curveTo([midX, point1[1]], [midX, point2[1]], point2); +} +class Renderer { + constructor(options) { + this.options = helper.extend({ layerGap: 60, nodeHeight: 10, direction: 'down' }, (options !== null && options !== void 0 ? options : {})); + } + getWaypoints(node) { + const { nodeHeight, layerGap, direction } = this.options; + const hops = node.getPathFromRoot(); + const gap = nodeHeight + layerGap; + if (direction === 'left') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1) * -1; + return [ + [xPos + nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'right') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1); + return [ + [xPos - nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'up') { + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1) * -1; + return [ + [hop.currentPos, yPos + nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + else { + // down + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1); + return [ + [hop.currentPos, yPos - nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + } + layout(nodes) { + const { layerGap, nodeHeight, direction } = this.options; + const gap = layerGap + nodeHeight; + switch (direction) { + case 'left': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = -pos - nodeHeight; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'right': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = pos; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'up': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = -pos - nodeHeight; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + default: + case 'down': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = pos; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + } + return nodes; + } + generatePath(node) { + const { direction } = this.options; + const waypoints = this.getWaypoints(node); + const steps = [moveTo(waypoints[0][0])]; + if (direction === 'left' || direction === 'right') { + waypoints.reduce((prev, current, level) => { + steps.push(hCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + else { + waypoints.reduce((prev, current, level) => { + steps.push(vCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + return steps.join(' '); + } +} +Renderer.lineTo = lineTo; +Renderer.moveTo = moveTo; +Renderer.curveTo = curveTo; +Renderer.vCurveBetween = vCurveBetween; +Renderer.hCurveBetween = hCurveBetween; + +function toLayers(nodes) { + if (nodes.length === 0) + return nodes; + return Array.isArray(nodes[0]) ? nodes : [nodes]; +} +function denominator(layers) { + return helper.sum(layers, (layer) => layer.length); +} +function denominatorWithoutStubs(layers) { + return helper.sum(layers, (layer) => layer.filter((l) => !l.isStub()).length); +} +const metrics = { + displacement(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.displacement())))) / denominatorWithoutStubs(layers)); + }, + pathLength(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.getPathToRootLength())))) / denominatorWithoutStubs(layers)); + }, + overflowSpace(nodes, minPos, maxPos) { + if (nodes.length === 0 || (!helper.isDefined(minPos) && !helper.isDefined(maxPos))) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => helper.sum(layer, (node) => { + const l = node.currentLeft(); + const r = node.currentRight(); + if (helper.isDefined(minPos) && minPos !== undefined && minPos !== null) { + if (r <= minPos) + return node.width; + else if (l < minPos) + return minPos - l; + } + if (helper.isDefined(maxPos) && maxPos !== undefined && maxPos !== null) { + if (l >= maxPos) + return node.width; + else if (r > maxPos) + return r - maxPos; + } + return 0; + })); + }, + overDensitySpace(nodes, density, layerWidth, nodeSpacing = 0) { + if (nodes.length === 0 || !helper.isDefined(density) || !helper.isDefined(layerWidth)) + return 0; + const limit = density * layerWidth; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + const width = helper.sum(layer, (node) => node.width + nodeSpacing) - nodeSpacing; + return width <= limit ? 0 : width - limit; + }); + }, + overlapCount(nodes, buffer) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + if (layer[i].overlapWithNode(layer[j], buffer)) + count++; + } + } + return count; + }); + }, + overlapSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + const distance = layer[i].distanceFrom(layer[j]); + count += distance < 0 ? Math.abs(distance) : 0; + } + } + return count; + }) / denominator(layers)); + }, + weightedAllocation(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * layer.filter((l) => !l.isStub()).length); + }, + weightedAllocatedSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * helper.sum(layer, (d) => d.width)); + }, +}; + +const util = { + generateNodes(amount, options) { + const nodes = []; + const opts = helper.extend({}, { minWidth: 20, maxWidth: 20, minPos: 0, maxPos: 800 }, (options !== null && options !== void 0 ? options : {})); + const diffPos = opts.maxPos - opts.minPos; + const diffWidth = opts.maxWidth - opts.minWidth; + for (let i = 0; i < amount; i++) { + nodes.push(new LabelNode(Math.floor(Math.random() * diffPos) + opts.minPos, Math.floor(Math.random() * diffWidth) + opts.minWidth)); + } + return nodes; + }, +}; + +export { Distributor, Force, LabelNode as Node, Renderer, metrics, util }; diff --git a/dist/labella.js b/dist/labella.js index aa4c987..a848e04 100644 --- a/dist/labella.js +++ b/dist/labella.js @@ -1,1969 +1,1417 @@ -(function webpackUniversalModuleDefinition(root, factory) { - if(typeof exports === 'object' && typeof module === 'object') - module.exports = factory(); - else if(typeof define === 'function' && define.amd) - define([], factory); - else if(typeof exports === 'object') - exports["labella"] = factory(); - else - root["labella"] = factory(); -})(this, function() { -return /******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; - -/******/ // The require function -/******/ function __webpack_require__(moduleId) { - -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) -/******/ return installedModules[moduleId].exports; - -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ exports: {}, -/******/ id: moduleId, -/******/ loaded: false -/******/ }; - -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); - -/******/ // Flag the module as loaded -/******/ module.loaded = true; - -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } - - -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; - -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; - -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = ""; - -/******/ // Load entry module and return exports -/******/ return __webpack_require__(0); -/******/ }) -/************************************************************************/ -/******/ ([ -/* 0 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - /* - Copyright 2015 Twitter, Inc. - Licensed under the Apache License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0 - */ - - module.exports = { - Node: __webpack_require__(1), - Force: __webpack_require__(2), - Distributor: __webpack_require__(3), - Renderer: __webpack_require__(10) - }; - -/***/ }, -/* 1 */ -/***/ function(module, exports) { - - 'use strict'; - - var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - - var Node = function () { - function Node(idealPos, width, data) { - _classCallCheck(this, Node); - - this.idealPos = idealPos; - this.currentPos = idealPos; - this.width = width; - this.data = data; - this.layerIndex = 0; - } - - // return negative if overlap - - - _createClass(Node, [{ - key: 'distanceFrom', - value: function distanceFrom(node) { - var halfWidth = this.width / 2; - var nodeHalfWidth = node.width / 2; - // max(a[0], b[0]) - min(a[1], b[1]) - return Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth); - } - }, { - key: 'moveToIdealPosition', - value: function moveToIdealPosition() { - this.currentPos = this.idealPos; - return this; - } - }, { - key: 'displacement', - value: function displacement() { - return this.idealPos - this.currentPos; - } - }, { - key: 'overlapWithNode', - value: function overlapWithNode(node) { - var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - - return this.distanceFrom(node) - buffer < 0; - } - }, { - key: 'overlapWithPoint', - value: function overlapWithPoint(pos) { - var halfWidth = this.width / 2; - return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; - } - }, { - key: 'positionBefore', - value: function positionBefore(node) { - var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - - return node.currentLeft() - this.width / 2 - buffer; - } - }, { - key: 'positionAfter', - value: function positionAfter(node) { - var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - - return node.currentRight() + this.width / 2 + buffer; - } - }, { - key: 'currentRight', - value: function currentRight() { - return this.currentPos + this.width / 2; - } - }, { - key: 'currentLeft', - value: function currentLeft() { - return this.currentPos - this.width / 2; - } - }, { - key: 'idealRight', - value: function idealRight() { - return this.idealPos + this.width / 2; - } - }, { - key: 'idealLeft', - value: function idealLeft() { - return this.idealPos - this.width / 2; - } - }, { - key: 'createStub', - value: function createStub(width) { - var stub = new Node(this.idealPos, width, this.data); - stub.currentPos = this.currentPos; - stub.child = this; - this.parent = stub; - return stub; - } - }, { - key: 'removeStub', - value: function removeStub() { - if (this.parent) { - this.parent.child = null; - this.parent = null; - } - return this; - } - }, { - key: 'isStub', - value: function isStub() { - return !!this.child; - } - }, { - key: 'getPathToRoot', - value: function getPathToRoot() { - var path = []; - var current = this; - while (current) { - path.push(current); - current = current.parent; - } - return path; - } - }, { - key: 'getPathFromRoot', - value: function getPathFromRoot() { - return this.getPathToRoot().reverse(); - } - }, { - key: 'getPathToRootLength', - value: function getPathToRootLength() { - var length = 0; - var current = this; - while (current) { - var targetPos = current.parent ? current.parent.currentPos : current.idealPos; - length += Math.abs(current.currentPos - targetPos); - current = current.parent; - } - - return length; - } - - // Trace back to the node without parent - - }, { - key: 'getRoot', - value: function getRoot() { - var previous = this; - var current = this; - while (current) { - previous = current; - current = current.parent; - } - return previous; - } - }, { - key: 'getLayerIndex', - value: function getLayerIndex() { - return this.layerIndex; - } - }, { - key: 'clone', - value: function clone() { - var node = new Node(this.idealPos, this.width, this.data); - node.currentPos = this.currentPos; - node.layerIndex = this.layerIndex; - return node; - } - }]); - - return Node; - }(); - - module.exports = Node; - -/***/ }, -/* 2 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - var Distributor = __webpack_require__(3); - var helper = __webpack_require__(4); - var removeOverlap = __webpack_require__(8); - - var DEFAULT_OPTIONS = { - nodeSpacing: 3, - minPos: 0, - maxPos: null, - - algorithm: 'overlap', - removeOverlap: true, - density: 0.85, - stubWidth: 1 - }; - - var Force = function Force(_options) { - var force = {}; - var options = helper.extend({}, DEFAULT_OPTIONS); - var distributor = new Distributor(); - var nodes = []; - var layers = null; - - force.nodes = function (x) { - if (!arguments.length) return nodes; - nodes = x; - layers = [x.concat()]; - return force; - }; - - force.getLayers = function () { - return layers; - }; - - force.options = function (x) { - if (!arguments.length) return options; - options = helper.extend(options, x); - - var disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); - if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { - disOptions.layerWidth = options.maxPos - options.minPos; - } else { - disOptions.layerWidth = null; - } - distributor.options(disOptions); - - return force; - }; - - force.options(_options); - - force.compute = function () { - var overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); - - nodes.forEach(function (node) { - node.removeStub(); - }); - - layers = distributor.distribute(nodes); - layers.map(function (nodes, layerIndex) { - nodes.forEach(function (node) { - node.layerIndex = layerIndex; - }); - if (options.removeOverlap) { - removeOverlap(nodes, overlapOptions); - } - }); - - return force; - }; - - force.start = function () { - console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); - }; - - return force; - }; - - Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; - - module.exports = Force; - -/***/ }, -/* 3 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - var helper = __webpack_require__(4); - var IntervalTree = __webpack_require__(6); - - var DEFAULT_OPTIONS = { - algorithm: 'overlap', - layerWidth: 1000, - density: 0.75, - nodeSpacing: 3, - stubWidth: 1 - }; - - var Distributor = function Distributor(options) { - var distributor = {}; - - options = helper.extend({}, DEFAULT_OPTIONS, options); - - distributor.options = function (x) { - if (!arguments.length) return options; - options = helper.extend(options, x); - return distributor; - }; - - distributor.computeRequiredWidth = function (nodes) { - return helper.sum(nodes, function (d) { - return d.width + options.nodeSpacing; - }) - options.nodeSpacing; - }; - - distributor.maxWidthPerLayer = function () { - return options.density * options.layerWidth; - }; - - distributor.needToSplit = function (nodes) { - return distributor.estimateRequiredLayers(nodes) > 1; - }; - - distributor.estimateRequiredLayers = function (nodes) { - return options.layerWidth ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) : 1; - }; - - var algorithms = { - simple: function simple(nodes) { - var numLayers = distributor.estimateRequiredLayers(nodes); - - var layers = []; - for (var i = 0; i < numLayers; i++) { - layers.push([]); - } - - nodes.forEach(function (node, i) { - var mod = i % numLayers; - layers[mod].push(node); - - var stub = node; - for (var j = mod - 1; j >= 0; j--) { - stub = stub.createStub(options.stubWidth); - layers[j].push(stub); - } - }); - - return layers; - }, - roundRobin: function roundRobin(nodes) { - var layers = []; - - return layers; - }, - overlap: function overlap(nodes) { - var layers = []; - var maxWidth = distributor.maxWidthPerLayer(); - - var puntedNodes = nodes.concat(); - var puntedWidth = distributor.computeRequiredWidth(puntedNodes); - - while (puntedWidth > maxWidth) { - distributor.countIdealOverlaps(puntedNodes); - - var nodesInCurrentLayer = puntedNodes.concat(); - var currentlayerWidth = puntedWidth; - puntedNodes = []; - - while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { - // Sort by overlaps - nodesInCurrentLayer.sort(function (a, b) { - return b.overlapCount - a.overlapCount; - }); - - // Remove the node with most overlap - var first = nodesInCurrentLayer.shift(); - - // Update width - currentlayerWidth -= first.width; - currentlayerWidth += options.stubWidth; - - // Update overlap count for the remaining nodes - first.overlaps.forEach(function (node) { - node.overlapCount--; - }); - - // Add removed node to the next layer - puntedNodes.push(first); - } - - layers.push(nodesInCurrentLayer); - - puntedWidth = distributor.computeRequiredWidth(puntedNodes); - } - - if (puntedNodes.length > 0) { - layers.push(puntedNodes); - } - - // Create stubs - // From last layer - for (var i = layers.length - 1; i >= 1; i--) { - var layer = layers[i]; - // For each node in the layer - for (var k = 0; k < layer.length; k++) { - var node = layer[k]; - // If it is not a stub - if (node.isStub()) continue; - // Create one stub for each layer above it - var stub = node; - for (var j = i - 1; j >= 0; j--) { - stub = stub.createStub(options.stubWidth); - layers[j].push(stub); - } - } - } - - return layers; - } - }; - - distributor.countIdealOverlaps = function (nodes) { - var iTree = new IntervalTree(options.layerWidth / 2); - nodes.forEach(function (node) { - iTree.add([node.idealLeft(), node.idealRight(), node]); - }); - - nodes.forEach(function (node) { - var overlaps = iTree.search(node.idealLeft(), node.idealRight()); - node.overlaps = overlaps.map(function (x) { - return x.data[2]; - }); - node.overlapCount = overlaps.length; - }); - - return nodes; - }; - - distributor.distribute = function (nodes) { - if (!nodes || nodes.length === 0) return []; - - if (options.algorithm == 'none' || !helper.isDefined(options.algorithm)) { - return [nodes]; - } - - if (!distributor.needToSplit(nodes)) { - return [nodes]; - } - - var sortedNodes = nodes.concat().sort(function (a, b) { - return a.idealPos - b.idealPos; - }); - - if (typeof options.algorithm == 'function') { - return options.algorithm(sortedNodes, options); - } else if (algorithms.hasOwnProperty(options.algorithm)) { - return algorithms[options.algorithm](sortedNodes); - } else { - throw 'Unknown algorithm: ' + options.algorithm; - } - }; - - return distributor; - }; - - Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS; - - // return module - module.exports = Distributor; - -/***/ }, -/* 4 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - var helper = { - isDefined: function isDefined(x) { - return x !== null && x !== undefined; - }, - last: function last(array) { - return array.length > 0 ? array[array.length - 1] : null; - }, - pick: function pick(object, keys) { - return keys.reduce(function (prev, key) { - prev[key] = object[key]; - return prev; - }, {}); - }, - sum: function sum(array, accessor) { - return array.map(accessor).reduce(function (prev, current) { - return prev + current; - }, 0); - } - }; - - helper.extend = __webpack_require__(5); - - module.exports = helper; - -/***/ }, -/* 5 */ -/***/ function(module, exports) { - - 'use strict'; - - var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - - /* - This file is modified from https://github.com/justmoon/node-extend - The MIT License (MIT) - - Copyright (c) 2014 Stefan Thomas - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - - var hasOwn = Object.prototype.hasOwnProperty; - var toStr = Object.prototype.toString; - - var isArray = function isArray(arr) { - if (typeof Array.isArray === 'function') { - return Array.isArray(arr); - } - - return toStr.call(arr) === '[object Array]'; - }; - - var isPlainObject = function isPlainObject(obj) { - 'use strict'; - - if (!obj || toStr.call(obj) !== '[object Object]') { - return false; - } - - var has_own_constructor = hasOwn.call(obj, 'constructor'); - var has_is_property_of_method = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); - // Not own constructor property must be Object - if (obj.constructor && !has_own_constructor && !has_is_property_of_method) { - return false; - } - - // Own properties are enumerated firstly, so to speed up, - // if last one is own, then all properties are own. - var key; - for (key in obj) {} - - return key === undefined || hasOwn.call(obj, key); - }; - - module.exports = function extend() { - 'use strict'; - - var options, - name, - src, - copy, - copyIsArray, - clone, - target = arguments[0], - i = 1, - length = arguments.length, - deep = false; - - // Handle a deep copy situation - if (typeof target === 'boolean') { - deep = target; - target = arguments[1] || {}; - // skip the boolean and the target - i = 2; - } else if ((typeof target === 'undefined' ? 'undefined' : _typeof(target)) !== 'object' && typeof target !== 'function' || target == null) { - target = {}; - } - - for (; i < length; ++i) { - options = arguments[i]; - // Only deal with non-null/undefined values - if (options != null) { - // Extend the base object - for (name in options) { - src = target[name]; - copy = options[name]; - - // Prevent never-ending loop - if (target === copy) { - continue; - } - - // Recurse if we're merging plain objects or arrays - if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { - if (copyIsArray) { - copyIsArray = false; - clone = src && isArray(src) ? src : []; - } else { - clone = src && isPlainObject(src) ? src : {}; - } - - // Never move original objects, clone them - target[name] = extend(deep, clone, copy); - - // Don't bring in undefined values - } else if (copy !== undefined) { - target[name] = copy; - } - } - } - } - - // Return the modified object - return target; - }; - -/***/ }, -/* 6 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - /* - This file is modified from https://github.com/shinout/interval-tree - - (The MIT License) - - Copyright (c) 2012 SHIN Suzuki - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - 'Software'), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY - CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE - SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - - var SortedList = __webpack_require__(7); - - /** - * IntervalTree - * - * @param (object) data: - * @param (number) center: - * @param (object) options: - * center: - * - **/ - function IntervalTree(center, options) { - options || (options = {}); - - this.startKey = options.startKey || 0; // start key - this.endKey = options.endKey || 1; // end key - this.intervalHash = {}; // id => interval object - this.pointTree = new SortedList({ // b-tree of start, end points - compare: function compare(a, b) { - if (a == null) return -1; - if (b == null) return 1; - var c = a[0] - b[0]; - return c > 0 ? 1 : c == 0 ? 0 : -1; - } - }); - - this._autoIncrement = 0; - - // index of the root node - if (!center || typeof center != 'number') { - throw new Error('you must specify center index as the 2nd argument.'); - } - - this.root = new Node(center, this); - } - - /** - * publid methods - **/ - - /** - * add new range - **/ - IntervalTree.prototype.add = function (data, id) { - if (this.intervalHash[id]) { - throw new Error('id ' + id + ' is already registered.'); - } - - if (id == undefined) { - while (this.intervalHash[this._autoIncrement]) { - this._autoIncrement++; - } - id = this._autoIncrement; - } - - var itvl = new Interval(data, id, this.startKey, this.endKey); - this.pointTree.insert([itvl.start, id]); - this.pointTree.insert([itvl.end, id]); - this.intervalHash[id] = itvl; - this._autoIncrement++; - _insert.call(this, this.root, itvl); - }; - - /** - * search - * - * @param (integer) val: - * @return (array) - **/ - IntervalTree.prototype.search = function (val1, val2) { - var ret = []; - if (typeof val1 != 'number') { - throw new Error(val1 + ': invalid input'); - } - - if (val2 == undefined) { - _pointSearch.call(this, this.root, val1, ret); - } else if (typeof val2 == 'number') { - _rangeSearch.call(this, val1, val2, ret); - } else { - throw new Error(val1 + ',' + val2 + ': invalid input'); - } - return ret; - }; - - /** - * remove: - **/ - IntervalTree.prototype.remove = function (interval_id) {}; - - /** - * private methods - **/ - - /** - * _insert - **/ - function _insert(node, itvl) { - if (itvl.end < node.idx) { - if (!node.left) { - node.left = new Node(itvl.start + itvl.end >> 1, this); - } - return _insert.call(this, node.left, itvl); - } - - if (node.idx < itvl.start) { - if (!node.right) { - node.right = new Node(itvl.start + itvl.end >> 1, this); - } - return _insert.call(this, node.right, itvl); - } - return node.insert(itvl); - } - - /** - * _pointSearch - * @param (Node) node - * @param (integer) idx - * @param (Array) arr - **/ - function _pointSearch(node, idx, arr) { - if (!node) return; - - if (idx < node.idx) { - node.starts.every(function (itvl) { - var bool = itvl.start <= idx; - if (bool) arr.push(itvl.result()); - return bool; - }); - return _pointSearch.call(this, node.left, idx, arr); - } else if (idx > node.idx) { - node.ends.every(function (itvl) { - var bool = itvl.end >= idx; - if (bool) arr.push(itvl.result()); - return bool; - }); - return _pointSearch.call(this, node.right, idx, arr); - } - // exact equal - else { - node.starts.map(function (itvl) { - arr.push(itvl.result()); - }); - } - } - - /** - * _rangeSearch - * @param (integer) start - * @param (integer) end - * @param (Array) arr - **/ - function _rangeSearch(start, end, arr) { - if (end - start <= 0) { - throw new Error('end must be greater than start. start: ' + start + ', end: ' + end); - } - var resultHash = {}; - - var wholeWraps = []; - _pointSearch.call(this, this.root, start + end >> 1, wholeWraps, true); - - wholeWraps.forEach(function (result) { - resultHash[result.id] = true; - }); - - var idx1 = this.pointTree.bsearch([start, null]); - var pointTreeArray = this.pointTree; - while (idx1 >= 0 && pointTreeArray[idx1][0] == start) { - idx1--; - } - - var idx2 = this.pointTree.bsearch([end, null]); - if (idx2 >= 0) { - var len = pointTreeArray.length - 1; - while (idx2 <= len && pointTreeArray[idx2][0] <= end) { - idx2++; - } - - pointTreeArray.slice(idx1 + 1, idx2).forEach(function (point) { - var id = point[1]; - resultHash[id] = true; - }, this); - - Object.keys(resultHash).forEach(function (id) { - var itvl = this.intervalHash[id]; - arr.push(itvl.result(start, end)); - }, this); - } - } - - /** - * subclasses - * - **/ - - /** - * Node : prototype of each node in a interval tree - * - **/ - function Node(idx) { - this.idx = idx; - this.starts = new SortedList({ - compare: function compare(a, b) { - if (a == null) return -1; - if (b == null) return 1; - var c = a.start - b.start; - return c > 0 ? 1 : c == 0 ? 0 : -1; - } - }); - - this.ends = new SortedList({ - compare: function compare(a, b) { - if (a == null) return -1; - if (b == null) return 1; - var c = a.end - b.end; - return c < 0 ? 1 : c == 0 ? 0 : -1; - } - }); - } - - /** - * insert an Interval object to this node - **/ - Node.prototype.insert = function (interval) { - this.starts.insert(interval); - this.ends.insert(interval); - }; - - /** - * Interval : prototype of interval info - **/ - function Interval(data, id, s, e) { - this.id = id; - this.start = data[s]; - this.end = data[e]; - this.data = data; - - if (typeof this.start != 'number' || typeof this.end != 'number') { - throw new Error('start, end must be number. start: ' + this.start + ', end: ' + this.end); - } - - if (this.start >= this.end) { - throw new Error('start must be smaller than end. start: ' + this.start + ', end: ' + this.end); - } - } - - /** - * get result object - **/ - Interval.prototype.result = function (start, end) { - var ret = { - id: this.id, - data: this.data - }; - if (typeof start == 'number' && typeof end == 'number') { - /** - * calc overlapping rate - **/ - var left = Math.max(this.start, start); - var right = Math.min(this.end, end); - var lapLn = right - left; - ret.rate1 = lapLn / (end - start); - ret.rate2 = lapLn / (this.end - this.start); - } - return ret; - }; - - module.exports = IntervalTree; - -/***/ }, -/* 7 */ -/***/ function(module, exports) { - - "use strict"; - - var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - - /* - This file is modified from https://github.com/shinout/SortedList - - (The MIT License) - - Copyright (c) 2012 SHIN Suzuki - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - 'Software'), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY - CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE - SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - - var SortedList = function SortedList() { - var arr = null, - options = {}, - args = arguments; - - ["0", "1"].forEach(function (n) { - var val = args[n]; - if (Array.isArray(val)) { - arr = val; - } else if (val && (typeof val === "undefined" ? "undefined" : _typeof(val)) == "object") { - options = val; - } - }); - - if (typeof options.filter == 'function') { - this._filter = options.filter; - } - - if (typeof options.compare == 'function') { - this._compare = options.compare; - } else if (typeof options.compare == 'string' && SortedList.compares[options.compare]) { - this._compare = SortedList.compares[options.compare]; - } - - this._unique = !!options.unique; - - if (options.resume && arr) { - arr.forEach(function (v, i) { - this.push(v); - }, this); - } else if (arr) this.insert.apply(this, arr); - }; - - /** - * SortedList.create(val1, val2) - * creates an instance - **/ - SortedList.create = function (val1, val2) { - return new SortedList(val1, val2); - }; - - SortedList.prototype = new Array(); - SortedList.prototype.constructor = Array.prototype.constructor; - - /** - * sorted.insertOne(val) - * insert one value - * returns false if failed, inserted position if succeed - **/ - SortedList.prototype.insertOne = function (val) { - var pos = this.bsearch(val); - if (this._unique && this.key(val, pos) != null) return false; - if (!this._filter(val, pos)) return false; - this.splice(pos + 1, 0, val); - return pos + 1; - }; - - /** - * sorted.insert(val1, val2, ...) - * insert multi values - * returns the list of the results of insertOne() - **/ - SortedList.prototype.insert = function () { - return Array.prototype.map.call(arguments, function (val) { - return this.insertOne(val); - }, this); - }; - - /** - * sorted.remove(pos) - * remove the value in the given position - **/ - SortedList.prototype.remove = function (pos) { - this.splice(pos, 1); - return this; - }; - - /** - * sorted.bsearch(val) - * @returns position of the value - **/ - SortedList.prototype.bsearch = function (val) { - if (!this.length) return -1; - var mpos, - spos = 0, - epos = this.length; - while (epos - spos > 1) { - mpos = Math.floor((spos + epos) / 2); - var mval = this[mpos]; - var comp = this._compare(val, mval); - if (comp == 0) return mpos; - if (comp > 0) spos = mpos;else epos = mpos; - } - return spos == 0 && this._compare(this[0], val) > 0 ? -1 : spos; - }; - - /** - * sorted.key(val) - * @returns first index if exists, null if not - **/ - SortedList.prototype.key = function (val, bsResult) { - if (bsResult == null) bsResult = this.bsearch(val); - var pos = bsResult; - if (pos == -1 || this._compare(this[pos], val) < 0) return pos + 1 < this.length && this._compare(this[pos + 1], val) == 0 ? pos + 1 : null; - while (pos >= 1 && this._compare(this[pos - 1], val) == 0) { - pos--; - }return pos; - }; - - /** - * sorted.key(val) - * @returns indexes if exists, null if not - **/ - SortedList.prototype.keys = function (val, bsResult) { - var ret = []; - if (bsResult == null) bsResult = this.bsearch(val); - var pos = bsResult; - while (pos >= 0 && this._compare(this[pos], val) == 0) { - ret.push(pos); - pos--; - } - - var len = this.length; - pos = bsResult + 1; - while (pos < len && this._compare(this[pos], val) == 0) { - ret.push(pos); - pos++; - } - return ret.length ? ret : null; - }; - - /** - * sorted.unique() - * @param createNew : create new instance - * @returns first index if exists, null if not - **/ - SortedList.prototype.unique = function (createNew) { - if (createNew) return this.filter(function (v, k) { - return k == 0 || this._compare(this[k - 1], v) != 0; - }, this); - var total = 0; - this.map(function (v, k) { - if (k == 0 || this._compare(this[k - 1], v) != 0) return null; - return k - total++; - }, this).forEach(function (k) { - if (k != null) this.remove(k); - }, this); - return this; - }; - - /** - * sorted.toArray() - * get raw array - **/ - SortedList.prototype.toArray = function () { - return this.slice(); - }; - - /** - * default filtration function - **/ - SortedList.prototype._filter = function (val, pos) { - return true; - }; - - /** - * comparison functions - **/ - SortedList.compares = { - "number": function number(a, b) { - var c = a - b; - return c > 0 ? 1 : c == 0 ? 0 : -1; - }, - - "string": function string(a, b) { - return a > b ? 1 : a == b ? 0 : -1; - } - }; - - /** - * sorted.compare(a, b) - * default comparison function - **/ - SortedList.prototype._compare = SortedList.compares["string"]; - - module.exports = SortedList; - -/***/ }, -/* 8 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - var helper = __webpack_require__(4); - var vpsc = __webpack_require__(9); - - var DEFAULT_OPTIONS = { - lineSpacing: 2, - nodeSpacing: 3, - minPos: 0, - maxPos: null - }; - - function nodeToVariable(node) { - var v = new vpsc.Variable(node.targetPos); - v.node = node; - return v; - } - - function removeOverlap(nodes, options) { - if (nodes.length > 0) { - options = helper.extend(DEFAULT_OPTIONS, options); - - // For nodes with stub, set target position to stub's current position - nodes.forEach(function (node, index) { - node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; - node.index = index; - }); - - var variables = nodes.concat().sort(function (a, b) { - var diff = a.targetPos - b.targetPos; - if (diff !== 0) return diff; - var diff2 = a.isStub() - b.isStub(); - if (diff2 !== 0) return diff2; - // If same position, use original order - return a.index - b.index; - }).map(nodeToVariable); - - var constraints = []; - for (var i = 1; i < variables.length; i++) { - var v1 = variables[i - 1]; - var v2 = variables[i]; - - var gap = void 0; - if (v1.node.isStub() && v2.node.isStub()) { - gap = (v1.node.width + v2.node.width) / 2 + options.lineSpacing; - } else { - gap = (v1.node.width + v2.node.width) / 2 + options.nodeSpacing; - } - constraints.push(new vpsc.Constraint(v1, v2, gap)); - } - - if (helper.isDefined(options.minPos)) { - var leftWall = new vpsc.Variable(options.minPos, 1e10); - var v = variables[0]; - constraints.push(new vpsc.Constraint(leftWall, v, v.node.width / 2)); - variables.unshift(leftWall); - } - - if (helper.isDefined(options.maxPos)) { - var rightWall = new vpsc.Variable(options.maxPos, 1e10); - var lastv = helper.last(variables); - constraints.push(new vpsc.Constraint(lastv, rightWall, lastv.node.width / 2)); - variables.push(rightWall); - } - - new vpsc.Solver(variables, constraints).solve(); - - variables.filter(function (v) { - return v.node; - }).map(function (v) { - v.node.currentPos = Math.round(v.position()); - return v; - }); - } - - return nodes; - } - - removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS; - - module.exports = removeOverlap; - -/***/ }, -/* 9 */ -/***/ function(module, exports) { - - "use strict"; - - /* - This file is compiled from https://github.com/tgdwyer/WebCola/blob/master/WebCola/src/vpsc.ts - and modified slightly. - - The MIT License (MIT) - - Copyright (c) 2013 Tim Dwyer - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in all - copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - SOFTWARE. - */ - - var vpsc = {}; - - var PositionStats = function () { - function PositionStats(scale) { - this.scale = scale; - this.AB = 0; - this.AD = 0; - this.A2 = 0; - } - PositionStats.prototype.addVariable = function (v) { - var ai = this.scale / v.scale; - var bi = v.offset / v.scale; - var wi = v.weight; - this.AB += wi * ai * bi; - this.AD += wi * ai * v.desiredPosition; - this.A2 += wi * ai * ai; - }; - PositionStats.prototype.getPosn = function () { - return (this.AD - this.AB) / this.A2; - }; - return PositionStats; - }(); - vpsc.PositionStats = PositionStats; - var Constraint = function () { - function Constraint(left, right, gap, equality) { - if (equality === void 0) { - equality = false; - } - this.left = left; - this.right = right; - this.gap = gap; - this.equality = equality; - this.active = false; - this.unsatisfiable = false; - this.left = left; - this.right = right; - this.gap = gap; - this.equality = equality; - } - Constraint.prototype.slack = function () { - return this.unsatisfiable ? Number.MAX_VALUE : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); - }; - return Constraint; - }(); - vpsc.Constraint = Constraint; - var Variable = function () { - function Variable(desiredPosition, weight, scale) { - if (weight === void 0) { - weight = 1; - } - if (scale === void 0) { - scale = 1; - } - this.desiredPosition = desiredPosition; - this.weight = weight; - this.scale = scale; - this.offset = 0; - } - Variable.prototype.dfdv = function () { - return 2.0 * this.weight * (this.position() - this.desiredPosition); - }; - Variable.prototype.position = function () { - return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; - }; - // visit neighbours by active constraints within the same block - Variable.prototype.visitNeighbours = function (prev, f) { - var ff = function ff(c, next) { - return c.active && prev !== next && f(c, next); - }; - this.cOut.forEach(function (c) { - return ff(c, c.right); - }); - this.cIn.forEach(function (c) { - return ff(c, c.left); - }); - }; - return Variable; - }(); - vpsc.Variable = Variable; - var Block = function () { - function Block(v) { - this.vars = []; - v.offset = 0; - this.ps = new PositionStats(v.scale); - this.addVariable(v); - } - Block.prototype.addVariable = function (v) { - v.block = this; - this.vars.push(v); - this.ps.addVariable(v); - this.posn = this.ps.getPosn(); - }; - // move the block where it needs to be to minimize cost - Block.prototype.updateWeightedPosition = function () { - this.ps.AB = this.ps.AD = this.ps.A2 = 0; - for (var i = 0, n = this.vars.length; i < n; ++i) { - this.ps.addVariable(this.vars[i]); - }this.posn = this.ps.getPosn(); - }; - Block.prototype.compute_lm = function (v, u, postAction) { - var _this = this; - var dfdv = v.dfdv(); - v.visitNeighbours(u, function (c, next) { - var _dfdv = _this.compute_lm(next, v, postAction); - if (next === c.right) { - dfdv += _dfdv * c.left.scale; - c.lm = _dfdv; - } else { - dfdv += _dfdv * c.right.scale; - c.lm = -_dfdv; - } - postAction(c); - }); - return dfdv / v.scale; - }; - Block.prototype.populateSplitBlock = function (v, prev) { - var _this = this; - v.visitNeighbours(prev, function (c, next) { - next.offset = v.offset + (next === c.right ? c.gap : -c.gap); - _this.addVariable(next); - _this.populateSplitBlock(next, v); - }); - }; - // traverse the active constraint tree applying visit to each active constraint - Block.prototype.traverse = function (visit, acc, v, prev) { - var _this = this; - if (v === void 0) { - v = this.vars[0]; - } - if (prev === void 0) { - prev = null; - } - v.visitNeighbours(prev, function (c, next) { - acc.push(visit(c)); - _this.traverse(visit, acc, next, v); - }); - }; - // calculate lagrangian multipliers on constraints and - // find the active constraint in this block with the smallest lagrangian. - // if the lagrangian is negative, then the constraint is a split candidate. - Block.prototype.findMinLM = function () { - var m = null; - this.compute_lm(this.vars[0], null, function (c) { - if (!c.equality && (m === null || c.lm < m.lm)) m = c; - }); - return m; - }; - Block.prototype.findMinLMBetween = function (lv, rv) { - this.compute_lm(lv, null, function () {}); - var m = null; - this.findPath(lv, null, rv, function (c, next) { - if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) m = c; - }); - return m; - }; - Block.prototype.findPath = function (v, prev, to, visit) { - var _this = this; - var endFound = false; - v.visitNeighbours(prev, function (c, next) { - if (!endFound && (next === to || _this.findPath(next, v, to, visit))) { - endFound = true; - visit(c, next); - } - }); - return endFound; - }; - // Search active constraint tree from u to see if there is a directed path to v. - // Returns true if path is found. - Block.prototype.isActiveDirectedPathBetween = function (u, v) { - if (u === v) return true; - var i = u.cOut.length; - while (i--) { - var c = u.cOut[i]; - if (c.active && this.isActiveDirectedPathBetween(c.right, v)) return true; - } - return false; - }; - // split the block into two by deactivating the specified constraint - Block.split = function (c) { - /* DEBUG - console.log("split on " + c); - console.assert(c.active, "attempt to split on inactive constraint"); - DEBUG */ - c.active = false; - return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; - }; - Block.createSplitBlock = function (startVar) { - var b = new Block(startVar); - b.populateSplitBlock(startVar, null); - return b; - }; - // find a split point somewhere between the specified variables - Block.prototype.splitBetween = function (vl, vr) { - /* DEBUG - console.assert(vl.block === this); - console.assert(vr.block === this); - DEBUG */ - var c = this.findMinLMBetween(vl, vr); - if (c !== null) { - var bs = Block.split(c); - return { constraint: c, lb: bs[0], rb: bs[1] }; - } - // couldn't find a split point - for example the active path is all equality constraints - return null; - }; - Block.prototype.mergeAcross = function (b, c, dist) { - c.active = true; - for (var i = 0, n = b.vars.length; i < n; ++i) { - var v = b.vars[i]; - v.offset += dist; - this.addVariable(v); - } - this.posn = this.ps.getPosn(); - }; - Block.prototype.cost = function () { - var sum = 0, - i = this.vars.length; - while (i--) { - var v = this.vars[i], - d = v.position() - v.desiredPosition; - sum += d * d * v.weight; - } - return sum; - }; - return Block; - }(); - vpsc.Block = Block; - var Blocks = function () { - function Blocks(vs) { - this.vs = vs; - var n = vs.length; - this.list = new Array(n); - while (n--) { - var b = new Block(vs[n]); - this.list[n] = b; - b.blockInd = n; - } - } - Blocks.prototype.cost = function () { - var sum = 0, - i = this.list.length; - while (i--) { - sum += this.list[i].cost(); - }return sum; - }; - Blocks.prototype.insert = function (b) { - /* DEBUG - console.assert(!this.contains(b), "blocks error: tried to reinsert block " + b.blockInd) - DEBUG */ - b.blockInd = this.list.length; - this.list.push(b); - /* DEBUG - console.log("insert block: " + b.blockInd); - this.contains(b); - DEBUG */ - }; - Blocks.prototype.remove = function (b) { - /* DEBUG - console.log("remove block: " + b.blockInd); - console.assert(this.contains(b)); - DEBUG */ - var last = this.list.length - 1; - var swapBlock = this.list[last]; - this.list.length = last; - if (b !== swapBlock) { - this.list[b.blockInd] = swapBlock; - swapBlock.blockInd = b.blockInd; - } - }; - // merge the blocks on either side of the specified constraint, by copying the smaller block into the larger - // and deleting the smaller. - Blocks.prototype.merge = function (c) { - var l = c.left.block, - r = c.right.block; - /* DEBUG - console.assert(l!==r, "attempt to merge within the same block"); - DEBUG */ - var dist = c.right.offset - c.left.offset - c.gap; - if (l.vars.length < r.vars.length) { - r.mergeAcross(l, c, dist); - this.remove(l); - } else { - l.mergeAcross(r, c, -dist); - this.remove(r); - } - /* DEBUG - console.assert(Math.abs(c.slack()) < 1e-6, "Error: Constraint should be at equality after merge!"); - console.log("merged on " + c); - DEBUG */ - }; - Blocks.prototype.forEach = function (f) { - this.list.forEach(f); - }; - // useful, for example, after variable desired positions change. - Blocks.prototype.updateBlockPositions = function () { - this.list.forEach(function (b) { - return b.updateWeightedPosition(); - }); - }; - // split each block across its constraint with the minimum lagrangian - Blocks.prototype.split = function (inactive) { - var _this = this; - this.updateBlockPositions(); - this.list.forEach(function (b) { - var v = b.findMinLM(); - if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { - b = v.left.block; - Block.split(v).forEach(function (nb) { - return _this.insert(nb); - }); - _this.remove(b); - inactive.push(v); - } - }); - }; - return Blocks; - }(); - vpsc.Blocks = Blocks; - var Solver = function () { - function Solver(vs, cs) { - this.vs = vs; - this.cs = cs; - this.vs = vs; - vs.forEach(function (v) { - v.cIn = [], v.cOut = []; - /* DEBUG - v.toString = () => "v" + vs.indexOf(v); - DEBUG */ - }); - this.cs = cs; - cs.forEach(function (c) { - c.left.cOut.push(c); - c.right.cIn.push(c); - /* DEBUG - c.toString = () => c.left + "+" + c.gap + "<=" + c.right + " slack=" + c.slack() + " active=" + c.active; - DEBUG */ - }); - this.inactive = cs.map(function (c) { - c.active = false;return c; - }); - this.bs = null; - } - Solver.prototype.cost = function () { - return this.bs.cost(); - }; - // set starting positions without changing desired positions. - // Note: it throws away any previous block structure. - Solver.prototype.setStartingPositions = function (ps) { - this.inactive = this.cs.map(function (c) { - c.active = false;return c; - }); - this.bs = new Blocks(this.vs); - this.bs.forEach(function (b, i) { - return b.posn = ps[i]; - }); - }; - Solver.prototype.setDesiredPositions = function (ps) { - this.vs.forEach(function (v, i) { - return v.desiredPosition = ps[i]; - }); - }; - /* DEBUG - private getId(v: Variable): number { - return this.vs.indexOf(v); - } - // sanity check of the index integrity of the inactive list - checkInactive(): void { - var inactiveCount = 0; - this.cs.forEach(c=> { - var i = this.inactive.indexOf(c); - console.assert(!c.active && i >= 0 || c.active && i < 0, "constraint should be in the inactive list if it is not active: " + c); - if (i >= 0) { - inactiveCount++; - } else { - console.assert(c.active, "inactive constraint not found in inactive list: " + c); - } - }); - console.assert(inactiveCount === this.inactive.length, inactiveCount + " inactive constraints found, " + this.inactive.length + "in inactive list"); - } - // after every call to satisfy the following should check should pass - checkSatisfied(): void { - this.cs.forEach(c=>console.assert(c.slack() >= vpsc.Solver.ZERO_UPPERBOUND, "Error: Unsatisfied constraint! "+c)); - } - DEBUG */ - Solver.prototype.mostViolated = function () { - var minSlack = Number.MAX_VALUE, - v = null, - l = this.inactive, - n = l.length, - deletePoint = n; - for (var i = 0; i < n; ++i) { - var c = l[i]; - if (c.unsatisfiable) continue; - var slack = c.slack(); - if (c.equality || slack < minSlack) { - minSlack = slack; - v = c; - deletePoint = i; - if (c.equality) break; - } - } - if (deletePoint !== n && (minSlack < Solver.ZERO_UPPERBOUND && !v.active || v.equality)) { - l[deletePoint] = l[n - 1]; - l.length = n - 1; - } - return v; - }; - // satisfy constraints by building block structure over violated constraints - // and moving the blocks to their desired positions - Solver.prototype.satisfy = function () { - if (this.bs == null) { - this.bs = new Blocks(this.vs); - } - /* DEBUG - console.log("satisfy: " + this.bs); - DEBUG */ - this.bs.split(this.inactive); - var v = null; - while ((v = this.mostViolated()) && (v.equality || v.slack() < Solver.ZERO_UPPERBOUND && !v.active)) { - var lb = v.left.block, - rb = v.right.block; - /* DEBUG - console.log("most violated is: " + v); - this.bs.contains(lb); - this.bs.contains(rb); - DEBUG */ - if (lb !== rb) { - this.bs.merge(v); - } else { - if (lb.isActiveDirectedPathBetween(v.right, v.left)) { - // cycle found! - v.unsatisfiable = true; - continue; - } - // constraint is within block, need to split first - var split = lb.splitBetween(v.left, v.right); - if (split !== null) { - this.bs.insert(split.lb); - this.bs.insert(split.rb); - this.bs.remove(lb); - this.inactive.push(split.constraint); - } else { - /* DEBUG - console.log("unsatisfiable constraint found"); - DEBUG */ - v.unsatisfiable = true; - continue; - } - if (v.slack() >= 0) { - /* DEBUG - console.log("violated constraint indirectly satisfied: " + v); - DEBUG */ - // v was satisfied by the above split! - this.inactive.push(v); - } else { - /* DEBUG - console.log("merge after split:"); - DEBUG */ - this.bs.merge(v); - } - } - } - /* DEBUG - this.checkSatisfied(); - DEBUG */ - }; - // repeatedly build and split block structure until we converge to an optimal solution - Solver.prototype.solve = function () { - this.satisfy(); - var lastcost = Number.MAX_VALUE, - cost = this.bs.cost(); - while (Math.abs(lastcost - cost) > 0.0001) { - this.satisfy(); - lastcost = cost; - cost = this.bs.cost(); - } - return cost; - }; - Solver.LAGRANGIAN_TOLERANCE = -1e-4; - Solver.ZERO_UPPERBOUND = -1e-10; - return Solver; - }(); - vpsc.Solver = Solver; - - module.exports = vpsc; - -/***/ }, -/* 10 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - var helper = __webpack_require__(4); - - function Renderer(options) { - this.options = helper.extend({ - layerGap: 60, - nodeHeight: 10, - direction: 'down' - }, options); - } - - function lineTo(point) { - return 'L ' + point.join(' '); - } - - function moveTo(point) { - return 'M ' + point.join(' '); - } - - function curveTo(c1, c2, point2) { - return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); - } - - function vCurveBetween(point1, point2) { - var midY = (point1[1] + point2[1]) / 2; - return curveTo([point1[0], midY], [point2[0], midY], point2); - } - - function hCurveBetween(point1, point2) { - var midX = (point1[0] + point2[0]) / 2; - return curveTo([midX, point1[1]], [midX, point2[1]], point2); - } - - Renderer.lineTo = lineTo; - Renderer.moveTo = moveTo; - Renderer.curveTo = curveTo; - Renderer.vCurveBetween = vCurveBetween; - Renderer.hCurveBetween = hCurveBetween; - - Renderer.prototype.getWaypoints = function (node) { - var options = this.options; - var direction = options.direction; - - var hops = node.getPathFromRoot(); - var gap = options.nodeHeight + options.layerGap; - - if (direction === 'left') { - return [[[0, hops[0].idealPos]]].concat(hops.map(function (hop, level) { - var xPos = gap * (level + 1) * -1; - return [[xPos + options.nodeHeight, hop.currentPos], [xPos, hop.currentPos]]; - })); - } else if (direction === 'right') { - return [[[0, hops[0].idealPos]]].concat(hops.map(function (hop, level) { - var xPos = gap * (level + 1); - return [[xPos - options.nodeHeight, hop.currentPos], [xPos, hop.currentPos]]; - })); - } else if (direction === 'up') { - return [[[hops[0].idealPos, 0]]].concat(hops.map(function (hop, level) { - var yPos = gap * (level + 1) * -1; - return [[hop.currentPos, yPos + options.nodeHeight], [hop.currentPos, yPos]]; - })); - } else { - return [[[hops[0].idealPos, 0]]].concat(hops.map(function (hop, level) { - var yPos = gap * (level + 1); - return [[hop.currentPos, yPos - options.nodeHeight], [hop.currentPos, yPos]]; - })); - } - }; - - Renderer.prototype.layout = function (nodes) { - var options = this.options; - - var gap = options.layerGap + options.nodeHeight; - - switch (options.direction) { - case 'left': - nodes.forEach(function (node) { - var pos = node.getLayerIndex() * gap + options.layerGap; - node.x = -pos - options.nodeHeight; - node.y = node.currentPos; - node.dx = options.nodeHeight; - node.dy = node.width; - }); - break; - case 'right': - nodes.forEach(function (node) { - var pos = node.getLayerIndex() * gap + options.layerGap; - node.x = pos; - node.y = node.currentPos; - node.dx = options.nodeHeight; - node.dy = node.width; - }); - break; - case 'up': - nodes.forEach(function (node) { - var pos = node.getLayerIndex() * gap + options.layerGap; - node.x = node.currentPos; - node.y = -pos - options.nodeHeight; - node.dx = node.width; - node.dy = options.nodeHeight; - }); - break; - default: - case 'down': - nodes.forEach(function (node) { - var pos = node.getLayerIndex() * gap + options.layerGap; - node.x = node.currentPos; - node.y = pos; - node.dx = node.width; - node.dy = options.nodeHeight; - }); - break; - } - - return nodes; - }; - - Renderer.prototype.generatePath = function (node) { - var options = this.options; - var direction = options.direction; - - var waypoints = this.getWaypoints(node, direction); - - var steps = [moveTo(waypoints[0][0])]; - - if (direction === 'left' || direction === 'right') { - waypoints.reduce(function (prev, current, level) { - steps.push(hCurveBetween(prev[prev.length - 1], current[0])); - if (level < waypoints.length - 1) { - steps.push(lineTo(current[1])); - } - return current; - }); - } else { - waypoints.reduce(function (prev, current, level) { - steps.push(vCurveBetween(prev[prev.length - 1], current[0])); - if (level < waypoints.length - 1) { - steps.push(lineTo(current[1])); - } - return current; - }); - } - - return steps.join(' '); - }; - - // return module - module.exports = Renderer; - -/***/ } -/******/ ]) -}); -; \ No newline at end of file +class LabelNode { + constructor(idealPos, width, data) { + this.idealPos = idealPos; + this.currentPos = idealPos; + this.width = width; + this.data = data; + this.layerIndex = 0; + this.parent = null; + this.child = null; + } + /** Returns negative if nodes overlap */ + distanceFrom(node) { + const halfWidth = this.width / 2; + const nodeHalfWidth = node.width / 2; + return (Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - + Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth)); + } + moveToIdealPosition() { + this.currentPos = this.idealPos; + return this; + } + displacement() { + return this.idealPos - this.currentPos; + } + overlapWithNode(node, buffer = 0) { + return this.distanceFrom(node) - buffer < 0; + } + overlapWithPoint(pos) { + const halfWidth = this.width / 2; + return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; + } + positionBefore(node, buffer = 0) { + return node.currentLeft() - this.width / 2 - buffer; + } + positionAfter(node, buffer = 0) { + return node.currentRight() + this.width / 2 + buffer; + } + currentRight() { + return this.currentPos + this.width / 2; + } + currentLeft() { + return this.currentPos - this.width / 2; + } + idealRight() { + return this.idealPos + this.width / 2; + } + idealLeft() { + return this.idealPos - this.width / 2; + } + createStub(width) { + const stub = new LabelNode(this.idealPos, width !== null && width !== void 0 ? width : this.width, this.data); + stub.currentPos = this.currentPos; + stub.child = this; + this.parent = stub; + return stub; + } + removeStub() { + if (this.parent) { + this.parent.child = null; + this.parent = null; + } + return this; + } + isStub() { + return !!this.child; + } + getPathToRoot() { + const path = []; + let current = this; + while (current) { + path.push(current); + current = current.parent; + } + return path; + } + getPathFromRoot() { + return this.getPathToRoot().reverse(); + } + getPathToRootLength() { + let length = 0; + let current = this; + while (current) { + const targetPos = current.parent ? current.parent.currentPos : current.idealPos; + length += Math.abs(current.currentPos - targetPos); + current = current.parent; + } + return length; + } + getRoot() { + let previous = this; + let current = this; + while (current) { + previous = current; + current = current.parent; + } + return previous; + } + getLayerIndex() { + return this.layerIndex; + } + clone() { + const node = new LabelNode(this.idealPos, this.width, this.data); + node.currentPos = this.currentPos; + node.layerIndex = this.layerIndex; + return node; + } +} + +/* +This file is modified from https://github.com/justmoon/node-extend +The MIT License (MIT) + +Copyright (c) 2014 Stefan Thomas +*/ +const hasOwn = Object.prototype.hasOwnProperty; +const toStr = Object.prototype.toString; +function isArray(arr) { + return Array.isArray(arr); +} +function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + const o = obj; + const has_own_constructor = hasOwn.call(o, 'constructor'); + const ctor = o.constructor; + const has_is_property_of_method = ctor && ctor.prototype && hasOwn.call(ctor.prototype, 'isPrototypeOf'); + if (ctor && !has_own_constructor && !has_is_property_of_method) { + return false; + } + let key; + for (key in o) { + // intentionally empty + } + return key === undefined || hasOwn.call(o, key); +} +function extend(...args) { + let target; + let i = 1; + const length = args.length; + let deep = false; + if (typeof args[0] === 'boolean') { + deep = args[0]; + target = args[1] || {}; + i = 2; + } + else if (typeof args[0] !== 'object' && typeof args[0] !== 'function' || args[0] == null) { + target = {}; + } + else { + target = args[0]; + } + for (; i < length; ++i) { + const options = args[i]; + if (options != null) { + for (const name in options) { + const src = target[name]; + const copy = options[name]; + if (target === copy) + continue; + let copyIsArray = false; + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + let clone; + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } + else { + clone = src && isPlainObject(src) ? src : {}; + } + target[name] = extend(deep, clone, copy); + } + else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + return target; +} + +const helper = { + isDefined(x) { + return x !== null && x !== undefined; + }, + last(array) { + return array.length > 0 ? array[array.length - 1] : null; + }, + pick(object, keys) { + return keys.reduce((prev, key) => { + prev[key] = object[key]; + return prev; + }, {}); + }, + sum(array, accessor) { + return array.map(accessor).reduce((prev, current) => prev + current, 0); + }, + extend, +}; + +/* +This file is modified from https://github.com/shinout/SortedList + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +class SortedList extends Array { + static create(val1, val2) { + return new SortedList(val1, val2); + } + constructor(arr, options) { + super(); + Object.setPrototypeOf(this, SortedList.prototype); + let resolvedArr = null; + let resolvedOptions = {}; + if (Array.isArray(arr)) { + resolvedArr = arr; + } + else if (arr && typeof arr === 'object') { + resolvedOptions = arr; + } + if (options) + resolvedOptions = options; + this._filter = typeof resolvedOptions.filter === 'function' + ? resolvedOptions.filter + : () => true; + if (typeof resolvedOptions.compare === 'function') { + this._compare = resolvedOptions.compare; + } + else if (typeof resolvedOptions.compare === 'string' && + SortedList.compares[resolvedOptions.compare]) { + this._compare = SortedList.compares[resolvedOptions.compare]; + } + else { + this._compare = SortedList.compares.string; + } + this._unique = !!resolvedOptions.unique; + if (resolvedArr) { + if (resolvedOptions.resume) { + resolvedArr.forEach((v) => this.push(v)); + } + else { + this.insert(...resolvedArr); + } + } + } + insertOne(val) { + const pos = this.bsearch(val); + if (this._unique && this.key(val, pos) != null) + return false; + if (!this._filter(val, pos)) + return false; + this.splice(pos + 1, 0, val); + return pos + 1; + } + insert(...vals) { + return vals.map((val) => this.insertOne(val)); + } + remove(pos) { + this.splice(pos, 1); + return this; + } + bsearch(val) { + if (!this.length) + return -1; + let spos = 0; + let epos = this.length; + while (epos - spos > 1) { + const mpos = Math.floor((spos + epos) / 2); + const mval = this[mpos]; + const comp = this._compare(val, mval); + if (comp === 0) + return mpos; + if (comp > 0) + spos = mpos; + else + epos = mpos; + } + return spos === 0 && this._compare(this[0], val) > 0 ? -1 : spos; + } + key(val, bsResult) { + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + if (pos === -1 || this._compare(this[pos], val) < 0) { + return pos + 1 < this.length && this._compare(this[pos + 1], val) === 0 ? pos + 1 : null; + } + while (pos >= 1 && this._compare(this[pos - 1], val) === 0) + pos--; + return pos; + } + searchKeys(val, bsResult) { + const ret = []; + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + while (pos >= 0 && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos--; + } + const len = this.length; + pos = bsResult + 1; + while (pos < len && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos++; + } + return ret.length ? ret : null; + } + unique(createNew) { + if (createNew) { + return this.filter((v, k) => k === 0 || this._compare(this[k - 1], v) !== 0); + } + let total = 0; + this.map((v, k) => { + if (k === 0 || this._compare(this[k - 1], v) !== 0) + return null; + return k - total++; + }).forEach((k) => { + if (k != null) + this.remove(k); + }); + return this; + } + toArray() { + return this.slice(); + } +} +SortedList.compares = { + number(a, b) { + const c = a - b; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + string(a, b) { + return a > b ? 1 : a === b ? 0 : -1; + }, +}; + +/* +This file is modified from https://github.com/shinout/interval-tree + +(The MIT License) +Copyright (c) 2012 SHIN Suzuki +*/ +function createInterval(data, id, s, e) { + const start = data[s]; + const end = data[e]; + if (typeof start !== 'number' || typeof end !== 'number') { + throw new Error(`start, end must be number. start: ${start}, end: ${end}`); + } + if (start >= end) { + throw new Error(`start must be smaller than end. start: ${start}, end: ${end}`); + } + return { + id, + start, + end, + data, + result(rangeStart, rangeEnd) { + const ret = { id, data }; + if (typeof rangeStart === 'number' && typeof rangeEnd === 'number') { + const left = Math.max(start, rangeStart); + const right = Math.min(end, rangeEnd); + const lapLn = right - left; + ret.rate1 = lapLn / (rangeEnd - rangeStart); + ret.rate2 = lapLn / (end - start); + } + return ret; + }, + }; +} +function createTreeNode(idx) { + return { + idx, + left: undefined, + right: undefined, + starts: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.start - b.start; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + ends: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.end - b.end; + return c < 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + insert(interval) { + this.starts.insertOne(interval); + this.ends.insertOne(interval); + }, + }; +} +function insertNode(tree, node, itvl) { + if (itvl.end < node.idx) { + if (!node.left) { + node.left = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.left, itvl); + } + if (node.idx < itvl.start) { + if (!node.right) { + node.right = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.right, itvl); + } + node.insert(itvl); +} +function pointSearch(node, idx, arr) { + if (!node) + return; + if (idx < node.idx) { + node.starts.every((itvl) => { + const bool = itvl.start <= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.left, idx, arr); + } + else if (idx > node.idx) { + node.ends.every((itvl) => { + const bool = itvl.end >= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.right, idx, arr); + } + else { + node.starts.forEach((itvl) => arr.push(itvl.result())); + } +} +class IntervalTree { + constructor(center, options = {}) { + var _a, _b; + this.startKey = (_a = options.startKey) !== null && _a !== void 0 ? _a : 0; + this.endKey = (_b = options.endKey) !== null && _b !== void 0 ? _b : 1; + this.intervalHash = {}; + this.pointTree = new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a[0] - b[0]; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }); + this._autoIncrement = 0; + if (!center || typeof center !== 'number') { + throw new Error('you must specify center index as the 2nd argument.'); + } + this.root = createTreeNode(center); + } + add(data, id) { + if (id !== undefined && this.intervalHash[id]) { + throw new Error(`id ${id} is already registered.`); + } + if (id === undefined) { + while (this.intervalHash[this._autoIncrement]) { + this._autoIncrement++; + } + id = this._autoIncrement; + } + const itvl = createInterval(data, id, this.startKey, this.endKey); + this.pointTree.insertOne([itvl.start, id]); + this.pointTree.insertOne([itvl.end, id]); + this.intervalHash[id] = itvl; + this._autoIncrement++; + insertNode(this, this.root, itvl); + } + search(val1, val2) { + const ret = []; + if (typeof val1 !== 'number') { + throw new Error(`${val1}: invalid input`); + } + if (val2 === undefined) { + pointSearch(this.root, val1, ret); + } + else if (typeof val2 === 'number') { + this._rangeSearch(val1, val2, ret); + } + else { + throw new Error(`${val1},${val2}: invalid input`); + } + return ret; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + remove(_intervalId) { + // not implemented + } + _rangeSearch(start, end, arr) { + if (end - start <= 0) { + throw new Error(`end must be greater than start. start: ${start}, end: ${end}`); + } + const resultHash = {}; + const wholeWraps = []; + pointSearch(this.root, (start + end) >> 1, wholeWraps); + wholeWraps.forEach((result) => { + resultHash[result.id] = true; + }); + let idx1 = this.pointTree.bsearch([start, 0]); + const pointTreeArray = this.pointTree; + while (idx1 >= 0 && pointTreeArray[idx1][0] === start) { + idx1--; + } + const idx2Start = this.pointTree.bsearch([end, 0]); + if (idx2Start >= 0) { + const len = pointTreeArray.length - 1; + let idx2 = idx2Start; + while (idx2 <= len && pointTreeArray[idx2][0] <= end) { + idx2++; + } + pointTreeArray.slice(idx1 + 1, idx2).forEach((point) => { + resultHash[point[1]] = true; + }); + Object.keys(resultHash).forEach((idStr) => { + const id = Number(idStr); + const itvl = this.intervalHash[id]; + arr.push(itvl.result(start, end)); + }); + } + } +} + +const DEFAULT_OPTIONS$2 = { + algorithm: 'overlap', + layerWidth: 1000, + density: 0.75, + nodeSpacing: 3, + stubWidth: 1, +}; +function _Distributor(initOptions) { + const distributor = {}; + let options = helper.extend({}, DEFAULT_OPTIONS$2); + if (initOptions) { + options = helper.extend(options, initOptions); + } + distributor.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + return distributor; + }; + distributor.computeRequiredWidth = function (nodes) { + var _a; + return helper.sum(nodes, (d) => { var _a; return d.width + ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); }) - ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); + }; + distributor.maxWidthPerLayer = function () { + var _a, _b; + return ((_a = options.density) !== null && _a !== void 0 ? _a : 0.75) * ((_b = options.layerWidth) !== null && _b !== void 0 ? _b : 1000); + }; + distributor.needToSplit = function (nodes) { + return distributor.estimateRequiredLayers(nodes) > 1; + }; + distributor.estimateRequiredLayers = function (nodes) { + return options.layerWidth + ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) + : 1; + }; + const algorithms = { + simple(nodes) { + const numLayers = distributor.estimateRequiredLayers(nodes); + const layers = []; + for (let i = 0; i < numLayers; i++) + layers.push([]); + nodes.forEach((node, i) => { + var _a; + const mod = i % numLayers; + layers[mod].push(node); + let stub = node; + for (let j = mod - 1; j >= 0; j--) { + stub = stub.createStub((_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1); + layers[j].push(stub); + } + }); + return layers; + }, + roundRobin(_nodes) { + return []; + }, + overlap(nodes) { + var _a, _b, _c; + const layers = []; + const maxWidth = distributor.maxWidthPerLayer(); + let puntedNodes = nodes.concat(); + let puntedWidth = distributor.computeRequiredWidth(puntedNodes); + while (puntedWidth > maxWidth) { + distributor.countIdealOverlaps(puntedNodes); + let nodesInCurrentLayer = puntedNodes.concat(); + let currentlayerWidth = puntedWidth; + puntedNodes = []; + while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { + nodesInCurrentLayer.sort((a, b) => { var _a, _b; return ((_a = b.overlapCount) !== null && _a !== void 0 ? _a : 0) - ((_b = a.overlapCount) !== null && _b !== void 0 ? _b : 0); }); + const first = nodesInCurrentLayer.shift(); + currentlayerWidth -= first.width; + currentlayerWidth += (_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1; + ((_b = first.overlaps) !== null && _b !== void 0 ? _b : []).forEach((node) => { + var _a; + node.overlapCount = ((_a = node.overlapCount) !== null && _a !== void 0 ? _a : 0) - 1; + }); + puntedNodes.push(first); + } + layers.push(nodesInCurrentLayer); + puntedWidth = distributor.computeRequiredWidth(puntedNodes); + } + if (puntedNodes.length > 0) + layers.push(puntedNodes); + for (let i = layers.length - 1; i >= 1; i--) { + const layer = layers[i]; + for (let k = 0; k < layer.length; k++) { + const node = layer[k]; + if (node.isStub()) + continue; + let stub = node; + for (let j = i - 1; j >= 0; j--) { + stub = stub.createStub((_c = options.stubWidth) !== null && _c !== void 0 ? _c : 1); + layers[j].push(stub); + } + } + } + return layers; + }, + }; + distributor.countIdealOverlaps = function (nodes) { + var _a; + const iTree = new IntervalTree(((_a = options.layerWidth) !== null && _a !== void 0 ? _a : 1000) / 2); + nodes.forEach((node) => { + iTree.add([node.idealLeft(), node.idealRight(), node]); + }); + nodes.forEach((node) => { + const overlaps = iTree.search(node.idealLeft(), node.idealRight()); + node.overlaps = overlaps.map((x) => x.data[2]); + node.overlapCount = overlaps.length; + }); + return nodes; + }; + distributor.distribute = function (nodes) { + if (!nodes || nodes.length === 0) + return []; + const algo = options.algorithm; + if (algo === 'none' || !helper.isDefined(algo)) + return [nodes]; + if (!distributor.needToSplit(nodes)) + return [nodes]; + const sortedNodes = nodes.concat().sort((a, b) => a.idealPos - b.idealPos); + if (typeof algo === 'function') { + return algo(sortedNodes, options); + } + else if (typeof algo === 'string' && Object.prototype.hasOwnProperty.call(algorithms, algo)) { + return algorithms[algo](sortedNodes); + } + else { + throw new Error('Unknown algorithm: ' + algo); + } + }; + return distributor; +} +const Distributor = _Distributor; +Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS$2; + +/* +This file is adapted from https://github.com/tgdwyer/WebCola/blob/master/src/vpsc.ts +and modified slightly. + +The MIT License (MIT) +Copyright (c) 2013 Tim Dwyer +*/ +class PositionStats { + constructor(scale) { + this.scale = scale; + this.AB = 0; + this.AD = 0; + this.A2 = 0; + } + addVariable(v) { + const ai = this.scale / v.scale; + const bi = v.offset / v.scale; + const wi = v.weight; + this.AB += wi * ai * bi; + this.AD += wi * ai * v.desiredPosition; + this.A2 += wi * ai * ai; + } + getPosn() { + return (this.AD - this.AB) / this.A2; + } +} +class Constraint { + constructor(left, right, gap, equality = false) { + this.left = left; + this.right = right; + this.gap = gap; + this.equality = equality; + this.active = false; + this.unsatisfiable = false; + } + slack() { + return this.unsatisfiable + ? Number.MAX_VALUE + : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); + } +} +class Variable { + constructor(desiredPosition, weight = 1, scale = 1) { + this.desiredPosition = desiredPosition; + this.weight = weight; + this.scale = scale; + this.offset = 0; + this.cIn = []; + this.cOut = []; + } + dfdv() { + return 2.0 * this.weight * (this.position() - this.desiredPosition); + } + position() { + return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; + } + visitNeighbours(prev, f) { + const ff = (c, next) => { + if (c.active && prev !== next) + f(c, next); + }; + this.cOut.forEach((c) => ff(c, c.right)); + this.cIn.forEach((c) => ff(c, c.left)); + } +} +class Block { + constructor(v) { + this.vars = []; + v.offset = 0; + this.ps = new PositionStats(v.scale); + this.posn = 0; + this.addVariable(v); + } + addVariable(v) { + v.block = this; + this.vars.push(v); + this.ps.addVariable(v); + this.posn = this.ps.getPosn(); + } + updateWeightedPosition() { + this.ps.AB = this.ps.AD = this.ps.A2 = 0; + for (let i = 0, n = this.vars.length; i < n; ++i) { + this.ps.addVariable(this.vars[i]); + } + this.posn = this.ps.getPosn(); + } + compute_lm(v, u, postAction) { + let dfdv = v.dfdv(); + v.visitNeighbours(u, (c, next) => { + const _dfdv = this.compute_lm(next, v, postAction); + if (next === c.right) { + dfdv += _dfdv * c.left.scale; + c.lm = _dfdv; + } + else { + dfdv += _dfdv * c.right.scale; + c.lm = -_dfdv; + } + postAction(c); + }); + return dfdv / v.scale; + } + populateSplitBlock(v, prev) { + v.visitNeighbours(prev, (c, next) => { + next.offset = v.offset + (next === c.right ? c.gap : -c.gap); + this.addVariable(next); + this.populateSplitBlock(next, v); + }); + } + traverse(visit, acc, v = this.vars[0], prev = null) { + v.visitNeighbours(prev, (c, next) => { + acc.push(visit(c)); + this.traverse(visit, acc, next, v); + }); + } + findMinLM() { + let m = null; + this.compute_lm(this.vars[0], null, (c) => { + if (!c.equality && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findMinLMBetween(lv, rv) { + this.compute_lm(lv, null, () => undefined); + let m = null; + this.findPath(lv, null, rv, (c, next) => { + if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findPath(v, prev, to, visit) { + let endFound = false; + v.visitNeighbours(prev, (c, next) => { + if (!endFound && (next === to || this.findPath(next, v, to, visit))) { + endFound = true; + visit(c, next); + } + }); + return endFound; + } + isActiveDirectedPathBetween(u, v) { + if (u === v) + return true; + let i = u.cOut.length; + while (i--) { + const c = u.cOut[i]; + if (c.active && this.isActiveDirectedPathBetween(c.right, v)) + return true; + } + return false; + } + static split(c) { + c.active = false; + return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; + } + static createSplitBlock(startVar) { + const b = new Block(startVar); + b.populateSplitBlock(startVar, null); + return b; + } + splitBetween(vl, vr) { + const c = this.findMinLMBetween(vl, vr); + if (c !== null) { + const bs = Block.split(c); + return { constraint: c, lb: bs[0], rb: bs[1] }; + } + return null; + } + mergeAcross(b, c, dist) { + c.active = true; + for (let i = 0, n = b.vars.length; i < n; ++i) { + const v = b.vars[i]; + v.offset += dist; + this.addVariable(v); + } + this.posn = this.ps.getPosn(); + } + cost() { + let sum = 0; + let i = this.vars.length; + while (i--) { + const v = this.vars[i]; + const d = v.position() - v.desiredPosition; + sum += d * d * v.weight; + } + return sum; + } +} +class Blocks { + constructor(vs) { + this.vs = vs; + const n = vs.length; + this.list = new Array(n); + let i = n; + while (i--) { + const b = new Block(vs[i]); + this.list[i] = b; + b.blockInd = i; + } + } + cost() { + let sum = 0; + let i = this.list.length; + while (i--) + sum += this.list[i].cost(); + return sum; + } + insert(b) { + b.blockInd = this.list.length; + this.list.push(b); + } + remove(b) { + const last = this.list.length - 1; + const swapBlock = this.list[last]; + this.list.length = last; + if (b !== swapBlock) { + this.list[b.blockInd] = swapBlock; + swapBlock.blockInd = b.blockInd; + } + } + merge(c) { + const l = c.left.block; + const r = c.right.block; + const dist = c.right.offset - c.left.offset - c.gap; + if (l.vars.length < r.vars.length) { + r.mergeAcross(l, c, dist); + this.remove(l); + } + else { + l.mergeAcross(r, c, -dist); + this.remove(r); + } + } + forEach(f) { + this.list.forEach(f); + } + updateBlockPositions() { + this.list.forEach((b) => b.updateWeightedPosition()); + } + split(inactive) { + this.updateBlockPositions(); + this.list.forEach((b) => { + const v = b.findMinLM(); + if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { + const origBlock = v.left.block; + Block.split(v).forEach((nb) => this.insert(nb)); + this.remove(origBlock); + inactive.push(v); + } + }); + } +} +class Solver { + constructor(vs, cs) { + this.vs = vs; + this.cs = cs; + vs.forEach((v) => { + v.cIn = []; + v.cOut = []; + }); + cs.forEach((c) => { + c.left.cOut.push(c); + c.right.cIn.push(c); + }); + this.inactive = cs.map((c) => { c.active = false; return c; }); + this.bs = null; + } + cost() { + return this.bs.cost(); + } + setStartingPositions(ps) { + this.inactive = this.cs.map((c) => { c.active = false; return c; }); + this.bs = new Blocks(this.vs); + this.bs.forEach((b, i) => { b.posn = ps[i]; }); + } + setDesiredPositions(ps) { + this.vs.forEach((v, i) => { v.desiredPosition = ps[i]; }); + } + mostViolated() { + let minSlack = Number.MAX_VALUE; + let v = null; + const l = this.inactive; + const n = l.length; + let deletePoint = n; + for (let i = 0; i < n; ++i) { + const c = l[i]; + if (c.unsatisfiable) + continue; + const slack = c.slack(); + if (c.equality || slack < minSlack) { + minSlack = slack; + v = c; + deletePoint = i; + if (c.equality) + break; + } + } + if (deletePoint !== n && + v !== null && + ((minSlack < Solver.ZERO_UPPERBOUND && !v.active) || v.equality)) { + l[deletePoint] = l[n - 1]; + l.length = n - 1; + } + return v; + } + satisfy() { + if (this.bs == null) { + this.bs = new Blocks(this.vs); + } + this.bs.split(this.inactive); + let v; + while ((v = this.mostViolated()) !== null && + (v.equality || (v.slack() < Solver.ZERO_UPPERBOUND && !v.active))) { + const lb = v.left.block; + const rb = v.right.block; + if (lb !== rb) { + this.bs.merge(v); + } + else { + if (lb.isActiveDirectedPathBetween(v.right, v.left)) { + v.unsatisfiable = true; + continue; + } + const split = lb.splitBetween(v.left, v.right); + if (split !== null) { + this.bs.insert(split.lb); + this.bs.insert(split.rb); + this.bs.remove(lb); + this.inactive.push(split.constraint); + } + else { + v.unsatisfiable = true; + continue; + } + if (v.slack() >= 0) { + this.inactive.push(v); + } + else { + this.bs.merge(v); + } + } + } + } + solve() { + this.satisfy(); + let lastcost = Number.MAX_VALUE; + let cost = this.bs.cost(); + while (Math.abs(lastcost - cost) > 0.0001) { + this.satisfy(); + lastcost = cost; + cost = this.bs.cost(); + } + return cost; + } +} +Solver.LAGRANGIAN_TOLERANCE = -1e-4; +Solver.ZERO_UPPERBOUND = -1e-10; + +const DEFAULT_OPTIONS$1 = { + lineSpacing: 2, + nodeSpacing: 3, + minPos: 0, + maxPos: null, +}; +function nodeToVariable(node) { + var _a; + const v = new Variable((_a = node.targetPos) !== null && _a !== void 0 ? _a : node.idealPos); + v['node'] = node; + return v; +} +function removeOverlap(nodes, options) { + if (nodes.length > 0) { + const opts = helper.extend({}, DEFAULT_OPTIONS$1, (options !== null && options !== void 0 ? options : {})); + nodes.forEach((node, index) => { + node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; + node.index = index; + }); + const variables = nodes + .concat() + .sort((a, b) => { + var _a, _b, _c, _d; + const diff = ((_a = a.targetPos) !== null && _a !== void 0 ? _a : 0) - ((_b = b.targetPos) !== null && _b !== void 0 ? _b : 0); + if (diff !== 0) + return diff; + const diff2 = (a.isStub() ? 1 : 0) - (b.isStub() ? 1 : 0); + if (diff2 !== 0) + return diff2; + return ((_c = a.index) !== null && _c !== void 0 ? _c : 0) - ((_d = b.index) !== null && _d !== void 0 ? _d : 0); + }) + .map(nodeToVariable); + const constraints = []; + for (let i = 1; i < variables.length; i++) { + const v1 = variables[i - 1]; + const v2 = variables[i]; + const n1 = v1['node']; + const n2 = v2['node']; + let gap; + if (n1.isStub() && n2.isStub()) { + gap = (n1.width + n2.width) / 2 + opts.lineSpacing; + } + else { + gap = (n1.width + n2.width) / 2 + opts.nodeSpacing; + } + constraints.push(new Constraint(v1, v2, gap)); + } + if (helper.isDefined(opts.minPos) && opts.minPos !== null) { + const leftWall = new Variable(opts.minPos, 1e10); + const v = variables[0]; + const vNode = v['node']; + constraints.push(new Constraint(leftWall, v, vNode.width / 2)); + variables.unshift(leftWall); + } + if (helper.isDefined(opts.maxPos) && opts.maxPos !== null) { + const rightWall = new Variable(opts.maxPos, 1e10); + const lastv = helper.last(variables); + const lastNode = lastv['node']; + constraints.push(new Constraint(lastv, rightWall, lastNode ? lastNode.width / 2 : 0)); + variables.push(rightWall); + } + new Solver(variables, constraints).solve(); + variables + .filter((v) => !!v['node']) + .forEach((v) => { + v['node'].currentPos = Math.round(v.position()); + }); + } + return nodes; +} +removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS$1; + +const DEFAULT_OPTIONS = { + nodeSpacing: 3, + minPos: 0, + maxPos: null, + algorithm: 'overlap', + removeOverlap: true, + density: 0.85, + stubWidth: 1, + lineSpacing: 2, +}; +function _Force(_options) { + const force = {}; + let options = { ...DEFAULT_OPTIONS }; + const distributor = Distributor(); + let nodes = []; + let layers = null; + force.nodes = function (x) { + if (!arguments.length) + return nodes; + nodes = x; + layers = [x.concat()]; + return force; + }; + force.getLayers = function () { + return layers; + }; + force.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + const disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); + if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { + disOptions.layerWidth = options.maxPos - options.minPos; + } + else { + disOptions.layerWidth = null; + } + distributor.options(disOptions); + return force; + }; + force.options(_options !== null && _options !== void 0 ? _options : {}); + force.compute = function () { + const overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); + nodes.forEach((node) => node.removeStub()); + layers = distributor.distribute(nodes); + layers.forEach((layerNodes, layerIndex) => { + layerNodes.forEach((node) => { + node.layerIndex = layerIndex; + }); + if (options.removeOverlap) { + removeOverlap(layerNodes, overlapOptions); + } + }); + return force; + }; + force.start = function () { + console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); + }; + return force; +} +const Force = _Force; +Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; + +function lineTo(point) { + return 'L ' + point.join(' '); +} +function moveTo(point) { + return 'M ' + point.join(' '); +} +function curveTo(c1, c2, point2) { + return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); +} +function vCurveBetween(point1, point2) { + const midY = (point1[1] + point2[1]) / 2; + return curveTo([point1[0], midY], [point2[0], midY], point2); +} +function hCurveBetween(point1, point2) { + const midX = (point1[0] + point2[0]) / 2; + return curveTo([midX, point1[1]], [midX, point2[1]], point2); +} +class Renderer { + constructor(options) { + this.options = helper.extend({ layerGap: 60, nodeHeight: 10, direction: 'down' }, (options !== null && options !== void 0 ? options : {})); + } + getWaypoints(node) { + const { nodeHeight, layerGap, direction } = this.options; + const hops = node.getPathFromRoot(); + const gap = nodeHeight + layerGap; + if (direction === 'left') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1) * -1; + return [ + [xPos + nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'right') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1); + return [ + [xPos - nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'up') { + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1) * -1; + return [ + [hop.currentPos, yPos + nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + else { + // down + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1); + return [ + [hop.currentPos, yPos - nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + } + layout(nodes) { + const { layerGap, nodeHeight, direction } = this.options; + const gap = layerGap + nodeHeight; + switch (direction) { + case 'left': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = -pos - nodeHeight; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'right': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = pos; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'up': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = -pos - nodeHeight; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + default: + case 'down': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = pos; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + } + return nodes; + } + generatePath(node) { + const { direction } = this.options; + const waypoints = this.getWaypoints(node); + const steps = [moveTo(waypoints[0][0])]; + if (direction === 'left' || direction === 'right') { + waypoints.reduce((prev, current, level) => { + steps.push(hCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + else { + waypoints.reduce((prev, current, level) => { + steps.push(vCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + return steps.join(' '); + } +} +Renderer.lineTo = lineTo; +Renderer.moveTo = moveTo; +Renderer.curveTo = curveTo; +Renderer.vCurveBetween = vCurveBetween; +Renderer.hCurveBetween = hCurveBetween; + +function toLayers(nodes) { + if (nodes.length === 0) + return nodes; + return Array.isArray(nodes[0]) ? nodes : [nodes]; +} +function denominator(layers) { + return helper.sum(layers, (layer) => layer.length); +} +function denominatorWithoutStubs(layers) { + return helper.sum(layers, (layer) => layer.filter((l) => !l.isStub()).length); +} +const metrics = { + displacement(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.displacement())))) / denominatorWithoutStubs(layers)); + }, + pathLength(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.getPathToRootLength())))) / denominatorWithoutStubs(layers)); + }, + overflowSpace(nodes, minPos, maxPos) { + if (nodes.length === 0 || (!helper.isDefined(minPos) && !helper.isDefined(maxPos))) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => helper.sum(layer, (node) => { + const l = node.currentLeft(); + const r = node.currentRight(); + if (helper.isDefined(minPos) && minPos !== undefined && minPos !== null) { + if (r <= minPos) + return node.width; + else if (l < minPos) + return minPos - l; + } + if (helper.isDefined(maxPos) && maxPos !== undefined && maxPos !== null) { + if (l >= maxPos) + return node.width; + else if (r > maxPos) + return r - maxPos; + } + return 0; + })); + }, + overDensitySpace(nodes, density, layerWidth, nodeSpacing = 0) { + if (nodes.length === 0 || !helper.isDefined(density) || !helper.isDefined(layerWidth)) + return 0; + const limit = density * layerWidth; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + const width = helper.sum(layer, (node) => node.width + nodeSpacing) - nodeSpacing; + return width <= limit ? 0 : width - limit; + }); + }, + overlapCount(nodes, buffer) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + if (layer[i].overlapWithNode(layer[j], buffer)) + count++; + } + } + return count; + }); + }, + overlapSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + const distance = layer[i].distanceFrom(layer[j]); + count += distance < 0 ? Math.abs(distance) : 0; + } + } + return count; + }) / denominator(layers)); + }, + weightedAllocation(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * layer.filter((l) => !l.isStub()).length); + }, + weightedAllocatedSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * helper.sum(layer, (d) => d.width)); + }, +}; + +const util = { + generateNodes(amount, options) { + const nodes = []; + const opts = helper.extend({}, { minWidth: 20, maxWidth: 20, minPos: 0, maxPos: 800 }, (options !== null && options !== void 0 ? options : {})); + const diffPos = opts.maxPos - opts.minPos; + const diffWidth = opts.maxWidth - opts.minWidth; + for (let i = 0; i < amount; i++) { + nodes.push(new LabelNode(Math.floor(Math.random() * diffPos) + opts.minPos, Math.floor(Math.random() * diffWidth) + opts.minWidth)); + } + return nodes; + }, +}; + +export { Distributor, Force, LabelNode as Node, Renderer, metrics, util }; diff --git a/dist/labella.js.map b/dist/labella.js.map new file mode 100644 index 0000000..7ed5e0d --- /dev/null +++ b/dist/labella.js.map @@ -0,0 +1 @@ +{"version":3,"file":"labella.js","sources":["../src/core/node.ts","../src/lib/extend.ts","../src/core/helper.ts","../src/lib/sortedList.ts","../src/lib/intervalTree.ts","../src/core/distributor.ts","../src/lib/vpsc.ts","../src/core/removeOverlap.ts","../src/core/force.ts","../src/core/renderer.ts","../src/core/metrics.ts","../src/core/util.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null],"names":["DEFAULT_OPTIONS"],"mappings":"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"} \ No newline at end of file diff --git a/dist/labella.umd.js b/dist/labella.umd.js new file mode 100644 index 0000000..fa45d99 --- /dev/null +++ b/dist/labella.umd.js @@ -0,0 +1,1430 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.labella = {})); +})(this, (function (exports) { 'use strict'; + + class LabelNode { + constructor(idealPos, width, data) { + this.idealPos = idealPos; + this.currentPos = idealPos; + this.width = width; + this.data = data; + this.layerIndex = 0; + this.parent = null; + this.child = null; + } + /** Returns negative if nodes overlap */ + distanceFrom(node) { + const halfWidth = this.width / 2; + const nodeHalfWidth = node.width / 2; + return (Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - + Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth)); + } + moveToIdealPosition() { + this.currentPos = this.idealPos; + return this; + } + displacement() { + return this.idealPos - this.currentPos; + } + overlapWithNode(node, buffer = 0) { + return this.distanceFrom(node) - buffer < 0; + } + overlapWithPoint(pos) { + const halfWidth = this.width / 2; + return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; + } + positionBefore(node, buffer = 0) { + return node.currentLeft() - this.width / 2 - buffer; + } + positionAfter(node, buffer = 0) { + return node.currentRight() + this.width / 2 + buffer; + } + currentRight() { + return this.currentPos + this.width / 2; + } + currentLeft() { + return this.currentPos - this.width / 2; + } + idealRight() { + return this.idealPos + this.width / 2; + } + idealLeft() { + return this.idealPos - this.width / 2; + } + createStub(width) { + const stub = new LabelNode(this.idealPos, width !== null && width !== void 0 ? width : this.width, this.data); + stub.currentPos = this.currentPos; + stub.child = this; + this.parent = stub; + return stub; + } + removeStub() { + if (this.parent) { + this.parent.child = null; + this.parent = null; + } + return this; + } + isStub() { + return !!this.child; + } + getPathToRoot() { + const path = []; + let current = this; + while (current) { + path.push(current); + current = current.parent; + } + return path; + } + getPathFromRoot() { + return this.getPathToRoot().reverse(); + } + getPathToRootLength() { + let length = 0; + let current = this; + while (current) { + const targetPos = current.parent ? current.parent.currentPos : current.idealPos; + length += Math.abs(current.currentPos - targetPos); + current = current.parent; + } + return length; + } + getRoot() { + let previous = this; + let current = this; + while (current) { + previous = current; + current = current.parent; + } + return previous; + } + getLayerIndex() { + return this.layerIndex; + } + clone() { + const node = new LabelNode(this.idealPos, this.width, this.data); + node.currentPos = this.currentPos; + node.layerIndex = this.layerIndex; + return node; + } + } + + /* + This file is modified from https://github.com/justmoon/node-extend + The MIT License (MIT) + + Copyright (c) 2014 Stefan Thomas + */ + const hasOwn = Object.prototype.hasOwnProperty; + const toStr = Object.prototype.toString; + function isArray(arr) { + return Array.isArray(arr); + } + function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + const o = obj; + const has_own_constructor = hasOwn.call(o, 'constructor'); + const ctor = o.constructor; + const has_is_property_of_method = ctor && ctor.prototype && hasOwn.call(ctor.prototype, 'isPrototypeOf'); + if (ctor && !has_own_constructor && !has_is_property_of_method) { + return false; + } + let key; + for (key in o) { + // intentionally empty + } + return key === undefined || hasOwn.call(o, key); + } + function extend(...args) { + let target; + let i = 1; + const length = args.length; + let deep = false; + if (typeof args[0] === 'boolean') { + deep = args[0]; + target = args[1] || {}; + i = 2; + } + else if (typeof args[0] !== 'object' && typeof args[0] !== 'function' || args[0] == null) { + target = {}; + } + else { + target = args[0]; + } + for (; i < length; ++i) { + const options = args[i]; + if (options != null) { + for (const name in options) { + const src = target[name]; + const copy = options[name]; + if (target === copy) + continue; + let copyIsArray = false; + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + let clone; + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } + else { + clone = src && isPlainObject(src) ? src : {}; + } + target[name] = extend(deep, clone, copy); + } + else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + return target; + } + + const helper = { + isDefined(x) { + return x !== null && x !== undefined; + }, + last(array) { + return array.length > 0 ? array[array.length - 1] : null; + }, + pick(object, keys) { + return keys.reduce((prev, key) => { + prev[key] = object[key]; + return prev; + }, {}); + }, + sum(array, accessor) { + return array.map(accessor).reduce((prev, current) => prev + current, 0); + }, + extend, + }; + + /* + This file is modified from https://github.com/shinout/SortedList + + (The MIT License) + Copyright (c) 2012 SHIN Suzuki + */ + class SortedList extends Array { + static create(val1, val2) { + return new SortedList(val1, val2); + } + constructor(arr, options) { + super(); + Object.setPrototypeOf(this, SortedList.prototype); + let resolvedArr = null; + let resolvedOptions = {}; + if (Array.isArray(arr)) { + resolvedArr = arr; + } + else if (arr && typeof arr === 'object') { + resolvedOptions = arr; + } + if (options) + resolvedOptions = options; + this._filter = typeof resolvedOptions.filter === 'function' + ? resolvedOptions.filter + : () => true; + if (typeof resolvedOptions.compare === 'function') { + this._compare = resolvedOptions.compare; + } + else if (typeof resolvedOptions.compare === 'string' && + SortedList.compares[resolvedOptions.compare]) { + this._compare = SortedList.compares[resolvedOptions.compare]; + } + else { + this._compare = SortedList.compares.string; + } + this._unique = !!resolvedOptions.unique; + if (resolvedArr) { + if (resolvedOptions.resume) { + resolvedArr.forEach((v) => this.push(v)); + } + else { + this.insert(...resolvedArr); + } + } + } + insertOne(val) { + const pos = this.bsearch(val); + if (this._unique && this.key(val, pos) != null) + return false; + if (!this._filter(val, pos)) + return false; + this.splice(pos + 1, 0, val); + return pos + 1; + } + insert(...vals) { + return vals.map((val) => this.insertOne(val)); + } + remove(pos) { + this.splice(pos, 1); + return this; + } + bsearch(val) { + if (!this.length) + return -1; + let spos = 0; + let epos = this.length; + while (epos - spos > 1) { + const mpos = Math.floor((spos + epos) / 2); + const mval = this[mpos]; + const comp = this._compare(val, mval); + if (comp === 0) + return mpos; + if (comp > 0) + spos = mpos; + else + epos = mpos; + } + return spos === 0 && this._compare(this[0], val) > 0 ? -1 : spos; + } + key(val, bsResult) { + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + if (pos === -1 || this._compare(this[pos], val) < 0) { + return pos + 1 < this.length && this._compare(this[pos + 1], val) === 0 ? pos + 1 : null; + } + while (pos >= 1 && this._compare(this[pos - 1], val) === 0) + pos--; + return pos; + } + searchKeys(val, bsResult) { + const ret = []; + if (bsResult == null) + bsResult = this.bsearch(val); + let pos = bsResult; + while (pos >= 0 && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos--; + } + const len = this.length; + pos = bsResult + 1; + while (pos < len && this._compare(this[pos], val) === 0) { + ret.push(pos); + pos++; + } + return ret.length ? ret : null; + } + unique(createNew) { + if (createNew) { + return this.filter((v, k) => k === 0 || this._compare(this[k - 1], v) !== 0); + } + let total = 0; + this.map((v, k) => { + if (k === 0 || this._compare(this[k - 1], v) !== 0) + return null; + return k - total++; + }).forEach((k) => { + if (k != null) + this.remove(k); + }); + return this; + } + toArray() { + return this.slice(); + } + } + SortedList.compares = { + number(a, b) { + const c = a - b; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + string(a, b) { + return a > b ? 1 : a === b ? 0 : -1; + }, + }; + + /* + This file is modified from https://github.com/shinout/interval-tree + + (The MIT License) + Copyright (c) 2012 SHIN Suzuki + */ + function createInterval(data, id, s, e) { + const start = data[s]; + const end = data[e]; + if (typeof start !== 'number' || typeof end !== 'number') { + throw new Error(`start, end must be number. start: ${start}, end: ${end}`); + } + if (start >= end) { + throw new Error(`start must be smaller than end. start: ${start}, end: ${end}`); + } + return { + id, + start, + end, + data, + result(rangeStart, rangeEnd) { + const ret = { id, data }; + if (typeof rangeStart === 'number' && typeof rangeEnd === 'number') { + const left = Math.max(start, rangeStart); + const right = Math.min(end, rangeEnd); + const lapLn = right - left; + ret.rate1 = lapLn / (rangeEnd - rangeStart); + ret.rate2 = lapLn / (end - start); + } + return ret; + }, + }; + } + function createTreeNode(idx) { + return { + idx, + left: undefined, + right: undefined, + starts: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.start - b.start; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + ends: new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a.end - b.end; + return c < 0 ? 1 : c === 0 ? 0 : -1; + }, + }), + insert(interval) { + this.starts.insertOne(interval); + this.ends.insertOne(interval); + }, + }; + } + function insertNode(tree, node, itvl) { + if (itvl.end < node.idx) { + if (!node.left) { + node.left = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.left, itvl); + } + if (node.idx < itvl.start) { + if (!node.right) { + node.right = createTreeNode((itvl.start + itvl.end) >> 1); + } + return insertNode(tree, node.right, itvl); + } + node.insert(itvl); + } + function pointSearch(node, idx, arr) { + if (!node) + return; + if (idx < node.idx) { + node.starts.every((itvl) => { + const bool = itvl.start <= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.left, idx, arr); + } + else if (idx > node.idx) { + node.ends.every((itvl) => { + const bool = itvl.end >= idx; + if (bool) + arr.push(itvl.result()); + return bool; + }); + pointSearch(node.right, idx, arr); + } + else { + node.starts.forEach((itvl) => arr.push(itvl.result())); + } + } + class IntervalTree { + constructor(center, options = {}) { + var _a, _b; + this.startKey = (_a = options.startKey) !== null && _a !== void 0 ? _a : 0; + this.endKey = (_b = options.endKey) !== null && _b !== void 0 ? _b : 1; + this.intervalHash = {}; + this.pointTree = new SortedList({ + compare(a, b) { + if (a == null) + return -1; + if (b == null) + return 1; + const c = a[0] - b[0]; + return c > 0 ? 1 : c === 0 ? 0 : -1; + }, + }); + this._autoIncrement = 0; + if (!center || typeof center !== 'number') { + throw new Error('you must specify center index as the 2nd argument.'); + } + this.root = createTreeNode(center); + } + add(data, id) { + if (id !== undefined && this.intervalHash[id]) { + throw new Error(`id ${id} is already registered.`); + } + if (id === undefined) { + while (this.intervalHash[this._autoIncrement]) { + this._autoIncrement++; + } + id = this._autoIncrement; + } + const itvl = createInterval(data, id, this.startKey, this.endKey); + this.pointTree.insertOne([itvl.start, id]); + this.pointTree.insertOne([itvl.end, id]); + this.intervalHash[id] = itvl; + this._autoIncrement++; + insertNode(this, this.root, itvl); + } + search(val1, val2) { + const ret = []; + if (typeof val1 !== 'number') { + throw new Error(`${val1}: invalid input`); + } + if (val2 === undefined) { + pointSearch(this.root, val1, ret); + } + else if (typeof val2 === 'number') { + this._rangeSearch(val1, val2, ret); + } + else { + throw new Error(`${val1},${val2}: invalid input`); + } + return ret; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + remove(_intervalId) { + // not implemented + } + _rangeSearch(start, end, arr) { + if (end - start <= 0) { + throw new Error(`end must be greater than start. start: ${start}, end: ${end}`); + } + const resultHash = {}; + const wholeWraps = []; + pointSearch(this.root, (start + end) >> 1, wholeWraps); + wholeWraps.forEach((result) => { + resultHash[result.id] = true; + }); + let idx1 = this.pointTree.bsearch([start, 0]); + const pointTreeArray = this.pointTree; + while (idx1 >= 0 && pointTreeArray[idx1][0] === start) { + idx1--; + } + const idx2Start = this.pointTree.bsearch([end, 0]); + if (idx2Start >= 0) { + const len = pointTreeArray.length - 1; + let idx2 = idx2Start; + while (idx2 <= len && pointTreeArray[idx2][0] <= end) { + idx2++; + } + pointTreeArray.slice(idx1 + 1, idx2).forEach((point) => { + resultHash[point[1]] = true; + }); + Object.keys(resultHash).forEach((idStr) => { + const id = Number(idStr); + const itvl = this.intervalHash[id]; + arr.push(itvl.result(start, end)); + }); + } + } + } + + const DEFAULT_OPTIONS$2 = { + algorithm: 'overlap', + layerWidth: 1000, + density: 0.75, + nodeSpacing: 3, + stubWidth: 1, + }; + function _Distributor(initOptions) { + const distributor = {}; + let options = helper.extend({}, DEFAULT_OPTIONS$2); + if (initOptions) { + options = helper.extend(options, initOptions); + } + distributor.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + return distributor; + }; + distributor.computeRequiredWidth = function (nodes) { + var _a; + return helper.sum(nodes, (d) => { var _a; return d.width + ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); }) - ((_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : 3); + }; + distributor.maxWidthPerLayer = function () { + var _a, _b; + return ((_a = options.density) !== null && _a !== void 0 ? _a : 0.75) * ((_b = options.layerWidth) !== null && _b !== void 0 ? _b : 1000); + }; + distributor.needToSplit = function (nodes) { + return distributor.estimateRequiredLayers(nodes) > 1; + }; + distributor.estimateRequiredLayers = function (nodes) { + return options.layerWidth + ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) + : 1; + }; + const algorithms = { + simple(nodes) { + const numLayers = distributor.estimateRequiredLayers(nodes); + const layers = []; + for (let i = 0; i < numLayers; i++) + layers.push([]); + nodes.forEach((node, i) => { + var _a; + const mod = i % numLayers; + layers[mod].push(node); + let stub = node; + for (let j = mod - 1; j >= 0; j--) { + stub = stub.createStub((_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1); + layers[j].push(stub); + } + }); + return layers; + }, + roundRobin(_nodes) { + return []; + }, + overlap(nodes) { + var _a, _b, _c; + const layers = []; + const maxWidth = distributor.maxWidthPerLayer(); + let puntedNodes = nodes.concat(); + let puntedWidth = distributor.computeRequiredWidth(puntedNodes); + while (puntedWidth > maxWidth) { + distributor.countIdealOverlaps(puntedNodes); + let nodesInCurrentLayer = puntedNodes.concat(); + let currentlayerWidth = puntedWidth; + puntedNodes = []; + while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { + nodesInCurrentLayer.sort((a, b) => { var _a, _b; return ((_a = b.overlapCount) !== null && _a !== void 0 ? _a : 0) - ((_b = a.overlapCount) !== null && _b !== void 0 ? _b : 0); }); + const first = nodesInCurrentLayer.shift(); + currentlayerWidth -= first.width; + currentlayerWidth += (_a = options.stubWidth) !== null && _a !== void 0 ? _a : 1; + ((_b = first.overlaps) !== null && _b !== void 0 ? _b : []).forEach((node) => { + var _a; + node.overlapCount = ((_a = node.overlapCount) !== null && _a !== void 0 ? _a : 0) - 1; + }); + puntedNodes.push(first); + } + layers.push(nodesInCurrentLayer); + puntedWidth = distributor.computeRequiredWidth(puntedNodes); + } + if (puntedNodes.length > 0) + layers.push(puntedNodes); + for (let i = layers.length - 1; i >= 1; i--) { + const layer = layers[i]; + for (let k = 0; k < layer.length; k++) { + const node = layer[k]; + if (node.isStub()) + continue; + let stub = node; + for (let j = i - 1; j >= 0; j--) { + stub = stub.createStub((_c = options.stubWidth) !== null && _c !== void 0 ? _c : 1); + layers[j].push(stub); + } + } + } + return layers; + }, + }; + distributor.countIdealOverlaps = function (nodes) { + var _a; + const iTree = new IntervalTree(((_a = options.layerWidth) !== null && _a !== void 0 ? _a : 1000) / 2); + nodes.forEach((node) => { + iTree.add([node.idealLeft(), node.idealRight(), node]); + }); + nodes.forEach((node) => { + const overlaps = iTree.search(node.idealLeft(), node.idealRight()); + node.overlaps = overlaps.map((x) => x.data[2]); + node.overlapCount = overlaps.length; + }); + return nodes; + }; + distributor.distribute = function (nodes) { + if (!nodes || nodes.length === 0) + return []; + const algo = options.algorithm; + if (algo === 'none' || !helper.isDefined(algo)) + return [nodes]; + if (!distributor.needToSplit(nodes)) + return [nodes]; + const sortedNodes = nodes.concat().sort((a, b) => a.idealPos - b.idealPos); + if (typeof algo === 'function') { + return algo(sortedNodes, options); + } + else if (typeof algo === 'string' && Object.prototype.hasOwnProperty.call(algorithms, algo)) { + return algorithms[algo](sortedNodes); + } + else { + throw new Error('Unknown algorithm: ' + algo); + } + }; + return distributor; + } + const Distributor = _Distributor; + Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS$2; + + /* + This file is adapted from https://github.com/tgdwyer/WebCola/blob/master/src/vpsc.ts + and modified slightly. + + The MIT License (MIT) + Copyright (c) 2013 Tim Dwyer + */ + class PositionStats { + constructor(scale) { + this.scale = scale; + this.AB = 0; + this.AD = 0; + this.A2 = 0; + } + addVariable(v) { + const ai = this.scale / v.scale; + const bi = v.offset / v.scale; + const wi = v.weight; + this.AB += wi * ai * bi; + this.AD += wi * ai * v.desiredPosition; + this.A2 += wi * ai * ai; + } + getPosn() { + return (this.AD - this.AB) / this.A2; + } + } + class Constraint { + constructor(left, right, gap, equality = false) { + this.left = left; + this.right = right; + this.gap = gap; + this.equality = equality; + this.active = false; + this.unsatisfiable = false; + } + slack() { + return this.unsatisfiable + ? Number.MAX_VALUE + : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); + } + } + class Variable { + constructor(desiredPosition, weight = 1, scale = 1) { + this.desiredPosition = desiredPosition; + this.weight = weight; + this.scale = scale; + this.offset = 0; + this.cIn = []; + this.cOut = []; + } + dfdv() { + return 2.0 * this.weight * (this.position() - this.desiredPosition); + } + position() { + return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; + } + visitNeighbours(prev, f) { + const ff = (c, next) => { + if (c.active && prev !== next) + f(c, next); + }; + this.cOut.forEach((c) => ff(c, c.right)); + this.cIn.forEach((c) => ff(c, c.left)); + } + } + class Block { + constructor(v) { + this.vars = []; + v.offset = 0; + this.ps = new PositionStats(v.scale); + this.posn = 0; + this.addVariable(v); + } + addVariable(v) { + v.block = this; + this.vars.push(v); + this.ps.addVariable(v); + this.posn = this.ps.getPosn(); + } + updateWeightedPosition() { + this.ps.AB = this.ps.AD = this.ps.A2 = 0; + for (let i = 0, n = this.vars.length; i < n; ++i) { + this.ps.addVariable(this.vars[i]); + } + this.posn = this.ps.getPosn(); + } + compute_lm(v, u, postAction) { + let dfdv = v.dfdv(); + v.visitNeighbours(u, (c, next) => { + const _dfdv = this.compute_lm(next, v, postAction); + if (next === c.right) { + dfdv += _dfdv * c.left.scale; + c.lm = _dfdv; + } + else { + dfdv += _dfdv * c.right.scale; + c.lm = -_dfdv; + } + postAction(c); + }); + return dfdv / v.scale; + } + populateSplitBlock(v, prev) { + v.visitNeighbours(prev, (c, next) => { + next.offset = v.offset + (next === c.right ? c.gap : -c.gap); + this.addVariable(next); + this.populateSplitBlock(next, v); + }); + } + traverse(visit, acc, v = this.vars[0], prev = null) { + v.visitNeighbours(prev, (c, next) => { + acc.push(visit(c)); + this.traverse(visit, acc, next, v); + }); + } + findMinLM() { + let m = null; + this.compute_lm(this.vars[0], null, (c) => { + if (!c.equality && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findMinLMBetween(lv, rv) { + this.compute_lm(lv, null, () => undefined); + let m = null; + this.findPath(lv, null, rv, (c, next) => { + if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) + m = c; + }); + return m; + } + findPath(v, prev, to, visit) { + let endFound = false; + v.visitNeighbours(prev, (c, next) => { + if (!endFound && (next === to || this.findPath(next, v, to, visit))) { + endFound = true; + visit(c, next); + } + }); + return endFound; + } + isActiveDirectedPathBetween(u, v) { + if (u === v) + return true; + let i = u.cOut.length; + while (i--) { + const c = u.cOut[i]; + if (c.active && this.isActiveDirectedPathBetween(c.right, v)) + return true; + } + return false; + } + static split(c) { + c.active = false; + return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; + } + static createSplitBlock(startVar) { + const b = new Block(startVar); + b.populateSplitBlock(startVar, null); + return b; + } + splitBetween(vl, vr) { + const c = this.findMinLMBetween(vl, vr); + if (c !== null) { + const bs = Block.split(c); + return { constraint: c, lb: bs[0], rb: bs[1] }; + } + return null; + } + mergeAcross(b, c, dist) { + c.active = true; + for (let i = 0, n = b.vars.length; i < n; ++i) { + const v = b.vars[i]; + v.offset += dist; + this.addVariable(v); + } + this.posn = this.ps.getPosn(); + } + cost() { + let sum = 0; + let i = this.vars.length; + while (i--) { + const v = this.vars[i]; + const d = v.position() - v.desiredPosition; + sum += d * d * v.weight; + } + return sum; + } + } + class Blocks { + constructor(vs) { + this.vs = vs; + const n = vs.length; + this.list = new Array(n); + let i = n; + while (i--) { + const b = new Block(vs[i]); + this.list[i] = b; + b.blockInd = i; + } + } + cost() { + let sum = 0; + let i = this.list.length; + while (i--) + sum += this.list[i].cost(); + return sum; + } + insert(b) { + b.blockInd = this.list.length; + this.list.push(b); + } + remove(b) { + const last = this.list.length - 1; + const swapBlock = this.list[last]; + this.list.length = last; + if (b !== swapBlock) { + this.list[b.blockInd] = swapBlock; + swapBlock.blockInd = b.blockInd; + } + } + merge(c) { + const l = c.left.block; + const r = c.right.block; + const dist = c.right.offset - c.left.offset - c.gap; + if (l.vars.length < r.vars.length) { + r.mergeAcross(l, c, dist); + this.remove(l); + } + else { + l.mergeAcross(r, c, -dist); + this.remove(r); + } + } + forEach(f) { + this.list.forEach(f); + } + updateBlockPositions() { + this.list.forEach((b) => b.updateWeightedPosition()); + } + split(inactive) { + this.updateBlockPositions(); + this.list.forEach((b) => { + const v = b.findMinLM(); + if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { + const origBlock = v.left.block; + Block.split(v).forEach((nb) => this.insert(nb)); + this.remove(origBlock); + inactive.push(v); + } + }); + } + } + class Solver { + constructor(vs, cs) { + this.vs = vs; + this.cs = cs; + vs.forEach((v) => { + v.cIn = []; + v.cOut = []; + }); + cs.forEach((c) => { + c.left.cOut.push(c); + c.right.cIn.push(c); + }); + this.inactive = cs.map((c) => { c.active = false; return c; }); + this.bs = null; + } + cost() { + return this.bs.cost(); + } + setStartingPositions(ps) { + this.inactive = this.cs.map((c) => { c.active = false; return c; }); + this.bs = new Blocks(this.vs); + this.bs.forEach((b, i) => { b.posn = ps[i]; }); + } + setDesiredPositions(ps) { + this.vs.forEach((v, i) => { v.desiredPosition = ps[i]; }); + } + mostViolated() { + let minSlack = Number.MAX_VALUE; + let v = null; + const l = this.inactive; + const n = l.length; + let deletePoint = n; + for (let i = 0; i < n; ++i) { + const c = l[i]; + if (c.unsatisfiable) + continue; + const slack = c.slack(); + if (c.equality || slack < minSlack) { + minSlack = slack; + v = c; + deletePoint = i; + if (c.equality) + break; + } + } + if (deletePoint !== n && + v !== null && + ((minSlack < Solver.ZERO_UPPERBOUND && !v.active) || v.equality)) { + l[deletePoint] = l[n - 1]; + l.length = n - 1; + } + return v; + } + satisfy() { + if (this.bs == null) { + this.bs = new Blocks(this.vs); + } + this.bs.split(this.inactive); + let v; + while ((v = this.mostViolated()) !== null && + (v.equality || (v.slack() < Solver.ZERO_UPPERBOUND && !v.active))) { + const lb = v.left.block; + const rb = v.right.block; + if (lb !== rb) { + this.bs.merge(v); + } + else { + if (lb.isActiveDirectedPathBetween(v.right, v.left)) { + v.unsatisfiable = true; + continue; + } + const split = lb.splitBetween(v.left, v.right); + if (split !== null) { + this.bs.insert(split.lb); + this.bs.insert(split.rb); + this.bs.remove(lb); + this.inactive.push(split.constraint); + } + else { + v.unsatisfiable = true; + continue; + } + if (v.slack() >= 0) { + this.inactive.push(v); + } + else { + this.bs.merge(v); + } + } + } + } + solve() { + this.satisfy(); + let lastcost = Number.MAX_VALUE; + let cost = this.bs.cost(); + while (Math.abs(lastcost - cost) > 0.0001) { + this.satisfy(); + lastcost = cost; + cost = this.bs.cost(); + } + return cost; + } + } + Solver.LAGRANGIAN_TOLERANCE = -1e-4; + Solver.ZERO_UPPERBOUND = -1e-10; + + const DEFAULT_OPTIONS$1 = { + lineSpacing: 2, + nodeSpacing: 3, + minPos: 0, + maxPos: null, + }; + function nodeToVariable(node) { + var _a; + const v = new Variable((_a = node.targetPos) !== null && _a !== void 0 ? _a : node.idealPos); + v['node'] = node; + return v; + } + function removeOverlap(nodes, options) { + if (nodes.length > 0) { + const opts = helper.extend({}, DEFAULT_OPTIONS$1, (options !== null && options !== void 0 ? options : {})); + nodes.forEach((node, index) => { + node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; + node.index = index; + }); + const variables = nodes + .concat() + .sort((a, b) => { + var _a, _b, _c, _d; + const diff = ((_a = a.targetPos) !== null && _a !== void 0 ? _a : 0) - ((_b = b.targetPos) !== null && _b !== void 0 ? _b : 0); + if (diff !== 0) + return diff; + const diff2 = (a.isStub() ? 1 : 0) - (b.isStub() ? 1 : 0); + if (diff2 !== 0) + return diff2; + return ((_c = a.index) !== null && _c !== void 0 ? _c : 0) - ((_d = b.index) !== null && _d !== void 0 ? _d : 0); + }) + .map(nodeToVariable); + const constraints = []; + for (let i = 1; i < variables.length; i++) { + const v1 = variables[i - 1]; + const v2 = variables[i]; + const n1 = v1['node']; + const n2 = v2['node']; + let gap; + if (n1.isStub() && n2.isStub()) { + gap = (n1.width + n2.width) / 2 + opts.lineSpacing; + } + else { + gap = (n1.width + n2.width) / 2 + opts.nodeSpacing; + } + constraints.push(new Constraint(v1, v2, gap)); + } + if (helper.isDefined(opts.minPos) && opts.minPos !== null) { + const leftWall = new Variable(opts.minPos, 1e10); + const v = variables[0]; + const vNode = v['node']; + constraints.push(new Constraint(leftWall, v, vNode.width / 2)); + variables.unshift(leftWall); + } + if (helper.isDefined(opts.maxPos) && opts.maxPos !== null) { + const rightWall = new Variable(opts.maxPos, 1e10); + const lastv = helper.last(variables); + const lastNode = lastv['node']; + constraints.push(new Constraint(lastv, rightWall, lastNode ? lastNode.width / 2 : 0)); + variables.push(rightWall); + } + new Solver(variables, constraints).solve(); + variables + .filter((v) => !!v['node']) + .forEach((v) => { + v['node'].currentPos = Math.round(v.position()); + }); + } + return nodes; + } + removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS$1; + + const DEFAULT_OPTIONS = { + nodeSpacing: 3, + minPos: 0, + maxPos: null, + algorithm: 'overlap', + removeOverlap: true, + density: 0.85, + stubWidth: 1, + lineSpacing: 2, + }; + function _Force(_options) { + const force = {}; + let options = { ...DEFAULT_OPTIONS }; + const distributor = Distributor(); + let nodes = []; + let layers = null; + force.nodes = function (x) { + if (!arguments.length) + return nodes; + nodes = x; + layers = [x.concat()]; + return force; + }; + force.getLayers = function () { + return layers; + }; + force.options = function (x) { + if (!arguments.length) + return options; + options = helper.extend(options, x); + const disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); + if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { + disOptions.layerWidth = options.maxPos - options.minPos; + } + else { + disOptions.layerWidth = null; + } + distributor.options(disOptions); + return force; + }; + force.options(_options !== null && _options !== void 0 ? _options : {}); + force.compute = function () { + const overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); + nodes.forEach((node) => node.removeStub()); + layers = distributor.distribute(nodes); + layers.forEach((layerNodes, layerIndex) => { + layerNodes.forEach((node) => { + node.layerIndex = layerIndex; + }); + if (options.removeOverlap) { + removeOverlap(layerNodes, overlapOptions); + } + }); + return force; + }; + force.start = function () { + console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); + }; + return force; + } + const Force = _Force; + Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; + + function lineTo(point) { + return 'L ' + point.join(' '); + } + function moveTo(point) { + return 'M ' + point.join(' '); + } + function curveTo(c1, c2, point2) { + return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); + } + function vCurveBetween(point1, point2) { + const midY = (point1[1] + point2[1]) / 2; + return curveTo([point1[0], midY], [point2[0], midY], point2); + } + function hCurveBetween(point1, point2) { + const midX = (point1[0] + point2[0]) / 2; + return curveTo([midX, point1[1]], [midX, point2[1]], point2); + } + class Renderer { + constructor(options) { + this.options = helper.extend({ layerGap: 60, nodeHeight: 10, direction: 'down' }, (options !== null && options !== void 0 ? options : {})); + } + getWaypoints(node) { + const { nodeHeight, layerGap, direction } = this.options; + const hops = node.getPathFromRoot(); + const gap = nodeHeight + layerGap; + if (direction === 'left') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1) * -1; + return [ + [xPos + nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'right') { + return [[[0, hops[0].idealPos]]].concat(hops.map((hop, level) => { + const xPos = gap * (level + 1); + return [ + [xPos - nodeHeight, hop.currentPos], + [xPos, hop.currentPos], + ]; + })); + } + else if (direction === 'up') { + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1) * -1; + return [ + [hop.currentPos, yPos + nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + else { + // down + return [[[hops[0].idealPos, 0]]].concat(hops.map((hop, level) => { + const yPos = gap * (level + 1); + return [ + [hop.currentPos, yPos - nodeHeight], + [hop.currentPos, yPos], + ]; + })); + } + } + layout(nodes) { + const { layerGap, nodeHeight, direction } = this.options; + const gap = layerGap + nodeHeight; + switch (direction) { + case 'left': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = -pos - nodeHeight; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'right': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = pos; + node.y = node.currentPos; + node.dx = nodeHeight; + node.dy = node.width; + }); + break; + case 'up': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = -pos - nodeHeight; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + default: + case 'down': + nodes.forEach((node) => { + const pos = node.getLayerIndex() * gap + layerGap; + node.x = node.currentPos; + node.y = pos; + node.dx = node.width; + node.dy = nodeHeight; + }); + break; + } + return nodes; + } + generatePath(node) { + const { direction } = this.options; + const waypoints = this.getWaypoints(node); + const steps = [moveTo(waypoints[0][0])]; + if (direction === 'left' || direction === 'right') { + waypoints.reduce((prev, current, level) => { + steps.push(hCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + else { + waypoints.reduce((prev, current, level) => { + steps.push(vCurveBetween(prev[prev.length - 1], current[0])); + if (level < waypoints.length - 1) { + steps.push(lineTo(current[1])); + } + return current; + }); + } + return steps.join(' '); + } + } + Renderer.lineTo = lineTo; + Renderer.moveTo = moveTo; + Renderer.curveTo = curveTo; + Renderer.vCurveBetween = vCurveBetween; + Renderer.hCurveBetween = hCurveBetween; + + function toLayers(nodes) { + if (nodes.length === 0) + return nodes; + return Array.isArray(nodes[0]) ? nodes : [nodes]; + } + function denominator(layers) { + return helper.sum(layers, (layer) => layer.length); + } + function denominatorWithoutStubs(layers) { + return helper.sum(layers, (layer) => layer.filter((l) => !l.isStub()).length); + } + const metrics = { + displacement(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.displacement())))) / denominatorWithoutStubs(layers)); + }, + pathLength(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => helper.sum(layer, (node) => (node.isStub() ? 0 : Math.abs(node.getPathToRootLength())))) / denominatorWithoutStubs(layers)); + }, + overflowSpace(nodes, minPos, maxPos) { + if (nodes.length === 0 || (!helper.isDefined(minPos) && !helper.isDefined(maxPos))) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => helper.sum(layer, (node) => { + const l = node.currentLeft(); + const r = node.currentRight(); + if (helper.isDefined(minPos) && minPos !== undefined && minPos !== null) { + if (r <= minPos) + return node.width; + else if (l < minPos) + return minPos - l; + } + if (helper.isDefined(maxPos) && maxPos !== undefined && maxPos !== null) { + if (l >= maxPos) + return node.width; + else if (r > maxPos) + return r - maxPos; + } + return 0; + })); + }, + overDensitySpace(nodes, density, layerWidth, nodeSpacing = 0) { + if (nodes.length === 0 || !helper.isDefined(density) || !helper.isDefined(layerWidth)) + return 0; + const limit = density * layerWidth; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + const width = helper.sum(layer, (node) => node.width + nodeSpacing) - nodeSpacing; + return width <= limit ? 0 : width - limit; + }); + }, + overlapCount(nodes, buffer) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + if (layer[i].overlapWithNode(layer[j], buffer)) + count++; + } + } + return count; + }); + }, + overlapSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return (helper.sum(layers, (layer) => { + let count = 0; + for (let i = 0; i < layer.length; i++) { + for (let j = i + 1; j < layer.length; j++) { + const distance = layer[i].distanceFrom(layer[j]); + count += distance < 0 ? Math.abs(distance) : 0; + } + } + return count; + }) / denominator(layers)); + }, + weightedAllocation(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * layer.filter((l) => !l.isStub()).length); + }, + weightedAllocatedSpace(nodes) { + if (nodes.length === 0) + return 0; + const layers = toLayers(nodes); + return helper.sum(layers, (layer, layerIndex) => layerIndex * helper.sum(layer, (d) => d.width)); + }, + }; + + const util = { + generateNodes(amount, options) { + const nodes = []; + const opts = helper.extend({}, { minWidth: 20, maxWidth: 20, minPos: 0, maxPos: 800 }, (options !== null && options !== void 0 ? options : {})); + const diffPos = opts.maxPos - opts.minPos; + const diffWidth = opts.maxWidth - opts.minWidth; + for (let i = 0; i < amount; i++) { + nodes.push(new LabelNode(Math.floor(Math.random() * diffPos) + opts.minPos, Math.floor(Math.random() * diffWidth) + opts.minWidth)); + } + return nodes; + }, + }; + + exports.Distributor = Distributor; + exports.Force = Force; + exports.Node = LabelNode; + exports.Renderer = Renderer; + exports.metrics = metrics; + exports.util = util; + +})); diff --git a/dist/labella.umd.js.map b/dist/labella.umd.js.map new file mode 100644 index 0000000..59d9722 --- /dev/null +++ b/dist/labella.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"labella.umd.js","sources":["../src/core/node.ts","../src/lib/extend.ts","../src/core/helper.ts","../src/lib/sortedList.ts","../src/lib/intervalTree.ts","../src/core/distributor.ts","../src/lib/vpsc.ts","../src/core/removeOverlap.ts","../src/core/force.ts","../src/core/renderer.ts","../src/core/metrics.ts","../src/core/util.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null],"names":["DEFAULT_OPTIONS"],"mappings":"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"} \ No newline at end of file diff --git a/dist/labella.umd.min.js b/dist/labella.umd.min.js new file mode 100644 index 0000000..6c2ca65 --- /dev/null +++ b/dist/labella.umd.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).labella={})}(this,function(t){"use strict";class e{constructor(t,e,s){this.idealPos=t,this.currentPos=t,this.width=e,this.data=s,this.layerIndex=0,this.parent=null,this.child=null}distanceFrom(t){const e=this.width/2,s=t.width/2;return Math.max(this.currentPos-e,t.currentPos-s)-Math.min(this.currentPos+e,t.currentPos+s)}moveToIdealPosition(){return this.currentPos=this.idealPos,this}displacement(){return this.idealPos-this.currentPos}overlapWithNode(t,e=0){return this.distanceFrom(t)-e<0}overlapWithPoint(t){const e=this.width/2;return t>=this.currentPos-e&&t<=this.currentPos+e}positionBefore(t,e=0){return t.currentLeft()-this.width/2-e}positionAfter(t,e=0){return t.currentRight()+this.width/2+e}currentRight(){return this.currentPos+this.width/2}currentLeft(){return this.currentPos-this.width/2}idealRight(){return this.idealPos+this.width/2}idealLeft(){return this.idealPos-this.width/2}createStub(t){const s=new e(this.idealPos,null!=t?t:this.width,this.data);return s.currentPos=this.currentPos,s.child=this,this.parent=s,s}removeStub(){return this.parent&&(this.parent.child=null,this.parent=null),this}isStub(){return!!this.child}getPathToRoot(){const t=[];let e=this;for(;e;)t.push(e),e=e.parent;return t}getPathFromRoot(){return this.getPathToRoot().reverse()}getPathToRootLength(){let t=0,e=this;for(;e;){const s=e.parent?e.parent.currentPos:e.idealPos;t+=Math.abs(e.currentPos-s),e=e.parent}return t}getRoot(){let t=this,e=this;for(;e;)t=e,e=e.parent;return t}getLayerIndex(){return this.layerIndex}clone(){const t=new e(this.idealPos,this.width,this.data);return t.currentPos=this.currentPos,t.layerIndex=this.layerIndex,t}}const s=Object.prototype.hasOwnProperty,n=Object.prototype.toString;function i(t){return Array.isArray(t)}function r(t){if(!t||"[object Object]"!==n.call(t))return!1;const e=t,i=s.call(e,"constructor"),r=e.constructor,o=r&&r.prototype&&s.call(r.prototype,"isPrototypeOf");if(r&&!i&&!o)return!1;let h;for(h in e);return void 0===h||s.call(e,h)}const o={isDefined:t=>null!=t,last:t=>t.length>0?t[t.length-1]:null,pick:(t,e)=>e.reduce((e,s)=>(e[s]=t[s],e),{}),sum:(t,e)=>t.map(e).reduce((t,e)=>t+e,0),extend:function t(...e){let s,n=1;const o=e.length;let h=!1;for("boolean"==typeof e[0]?(h=e[0],s=e[1]||{},n=2):s="object"!=typeof e[0]&&"function"!=typeof e[0]||null==e[0]?{}:e[0];n!0,"function"==typeof n.compare?this._compare=n.compare:"string"==typeof n.compare&&h.compares[n.compare]?this._compare=h.compares[n.compare]:this._compare=h.compares.string,this._unique=!!n.unique,s&&(n.resume?s.forEach(t=>this.push(t)):this.insert(...s))}insertOne(t){const e=this.bsearch(t);return(!this._unique||null==this.key(t,e))&&(!!this._filter(t,e)&&(this.splice(e+1,0,t),e+1))}insert(...t){return t.map(t=>this.insertOne(t))}remove(t){return this.splice(t,1),this}bsearch(t){if(!this.length)return-1;let e=0,s=this.length;for(;s-e>1;){const n=Math.floor((e+s)/2),i=this[n],r=this._compare(t,i);if(0===r)return n;r>0?e=n:s=n}return 0===e&&this._compare(this[0],t)>0?-1:e}key(t,e){null==e&&(e=this.bsearch(t));let s=e;if(-1===s||this._compare(this[s],t)<0)return s+1=1&&0===this._compare(this[s-1],t);)s--;return s}searchKeys(t,e){const s=[];null==e&&(e=this.bsearch(t));let n=e;for(;n>=0&&0===this._compare(this[n],t);)s.push(n),n--;const i=this.length;for(n=e+1;n0===e||0!==this._compare(this[e-1],t));let e=0;return this.map((t,s)=>0===s||0!==this._compare(this[s-1],t)?null:s-e++).forEach(t=>{null!=t&&this.remove(t)}),this}toArray(){return this.slice()}}function l(t){return{idx:t,left:void 0,right:void 0,starts:new h({compare(t,e){if(null==t)return-1;if(null==e)return 1;const s=t.start-e.start;return s>0?1:0===s?0:-1}}),ends:new h({compare(t,e){if(null==t)return-1;if(null==e)return 1;const s=t.end-e.end;return s<0?1:0===s?0:-1}}),insert(t){this.starts.insertOne(t),this.ends.insertOne(t)}}}function a(t,e,s){return s.end>1)),a(t,e.left,s)):e.idx>1)),a(t,e.right,s)):void e.insert(s)}function u(t,e,s){t&&(e{const n=t.start<=e;return n&&s.push(t.result()),n}),u(t.left,e,s)):e>t.idx?(t.ends.every(t=>{const n=t.end>=e;return n&&s.push(t.result()),n}),u(t.right,e,s)):t.starts.forEach(t=>s.push(t.result())))}h.compares={number(t,e){const s=t-e;return s>0?1:0===s?0:-1},string:(t,e)=>t>e?1:t===e?0:-1};class c{constructor(t,e={}){var s,n;if(this.startKey=null!==(s=e.startKey)&&void 0!==s?s:0,this.endKey=null!==(n=e.endKey)&&void 0!==n?n:1,this.intervalHash={},this.pointTree=new h({compare(t,e){if(null==t)return-1;if(null==e)return 1;const s=t[0]-e[0];return s>0?1:0===s?0:-1}}),this._autoIncrement=0,!t||"number"!=typeof t)throw new Error("you must specify center index as the 2nd argument.");this.root=l(t)}add(t,e){if(void 0!==e&&this.intervalHash[e])throw new Error(`id ${e} is already registered.`);if(void 0===e){for(;this.intervalHash[this._autoIncrement];)this._autoIncrement++;e=this._autoIncrement}const s=function(t,e,s,n){const i=t[s],r=t[n];if("number"!=typeof i||"number"!=typeof r)throw new Error(`start, end must be number. start: ${i}, end: ${r}`);if(i>=r)throw new Error(`start must be smaller than end. start: ${i}, end: ${r}`);return{id:e,start:i,end:r,data:t,result(s,n){const o={id:e,data:t};if("number"==typeof s&&"number"==typeof n){const t=Math.max(i,s),e=Math.min(r,n)-t;o.rate1=e/(n-s),o.rate2=e/(r-i)}return o}}}(t,e,this.startKey,this.endKey);this.pointTree.insertOne([s.start,e]),this.pointTree.insertOne([s.end,e]),this.intervalHash[e]=s,this._autoIncrement++,a(this,this.root,s)}search(t,e){const s=[];if("number"!=typeof t)throw new Error(`${t}: invalid input`);if(void 0===e)u(this.root,t,s);else{if("number"!=typeof e)throw new Error(`${t},${e}: invalid input`);this._rangeSearch(t,e,s)}return s}remove(t){}_rangeSearch(t,e,s){if(e-t<=0)throw new Error(`end must be greater than start. start: ${t}, end: ${e}`);const n={},i=[];u(this.root,t+e>>1,i),i.forEach(t=>{n[t.id]=!0});let r=this.pointTree.bsearch([t,0]);const o=this.pointTree;for(;r>=0&&o[r][0]===t;)r--;const h=this.pointTree.bsearch([e,0]);if(h>=0){const i=o.length-1;let l=h;for(;l<=i&&o[l][0]<=e;)l++;o.slice(r+1,l).forEach(t=>{n[t[1]]=!0}),Object.keys(n).forEach(n=>{const i=Number(n),r=this.intervalHash[i];s.push(r.result(t,e))})}}}const d={algorithm:"overlap",layerWidth:1e3,density:.75,nodeSpacing:3,stubWidth:1};const f=function(t){const e={};let s=o.extend({},d);t&&(s=o.extend(s,t)),e.options=function(t){return arguments.length?(s=o.extend(s,t),e):s},e.computeRequiredWidth=function(t){var e;return o.sum(t,t=>{var e;return t.width+(null!==(e=s.nodeSpacing)&&void 0!==e?e:3)})-(null!==(e=s.nodeSpacing)&&void 0!==e?e:3)},e.maxWidthPerLayer=function(){var t,e;return(null!==(t=s.density)&&void 0!==t?t:.75)*(null!==(e=s.layerWidth)&&void 0!==e?e:1e3)},e.needToSplit=function(t){return e.estimateRequiredLayers(t)>1},e.estimateRequiredLayers=function(t){return s.layerWidth?Math.ceil(e.computeRequiredWidth(t)/e.maxWidthPerLayer()):1};const n={simple(t){const n=e.estimateRequiredLayers(t),i=[];for(let t=0;t{var r;const o=e%n;i[o].push(t);let h=t;for(let t=o-1;t>=0;t--)h=h.createStub(null!==(r=s.stubWidth)&&void 0!==r?r:1),i[t].push(h)}),i},roundRobin:t=>[],overlap(t){var n,i,r;const o=[],h=e.maxWidthPerLayer();let l=t.concat(),a=e.computeRequiredWidth(l);for(;a>h;){e.countIdealOverlaps(l);let t=l.concat(),r=a;for(l=[];t.length>2&&r>h;){t.sort((t,e)=>{var s,n;return(null!==(s=e.overlapCount)&&void 0!==s?s:0)-(null!==(n=t.overlapCount)&&void 0!==n?n:0)});const e=t.shift();r-=e.width,r+=null!==(n=s.stubWidth)&&void 0!==n?n:1,(null!==(i=e.overlaps)&&void 0!==i?i:[]).forEach(t=>{var e;t.overlapCount=(null!==(e=t.overlapCount)&&void 0!==e?e:0)-1}),l.push(e)}o.push(t),a=e.computeRequiredWidth(l)}l.length>0&&o.push(l);for(let t=o.length-1;t>=1;t--){const e=o[t];for(let n=0;n=0;e--)h=h.createStub(null!==(r=s.stubWidth)&&void 0!==r?r:1),o[e].push(h)}}return o}};return e.countIdealOverlaps=function(t){var e;const n=new c((null!==(e=s.layerWidth)&&void 0!==e?e:1e3)/2);return t.forEach(t=>{n.add([t.idealLeft(),t.idealRight(),t])}),t.forEach(t=>{const e=n.search(t.idealLeft(),t.idealRight());t.overlaps=e.map(t=>t.data[2]),t.overlapCount=e.length}),t},e.distribute=function(t){if(!t||0===t.length)return[];const i=s.algorithm;if("none"===i||!o.isDefined(i))return[t];if(!e.needToSplit(t))return[t];const r=t.concat().sort((t,e)=>t.idealPos-e.idealPos);if("function"==typeof i)return i(r,s);if("string"==typeof i&&Object.prototype.hasOwnProperty.call(n,i))return n[i](r);throw new Error("Unknown algorithm: "+i)},e};f.DEFAULT_OPTIONS=d;class p{constructor(t){this.scale=t,this.AB=0,this.AD=0,this.A2=0}addVariable(t){const e=this.scale/t.scale,s=t.offset/t.scale,n=t.weight;this.AB+=n*e*s,this.AD+=n*e*t.desiredPosition,this.A2+=n*e*e}getPosn(){return(this.AD-this.AB)/this.A2}}class m{constructor(t,e,s,n=!1){this.left=t,this.right=e,this.gap=s,this.equality=n,this.active=!1,this.unsatisfiable=!1}slack(){return this.unsatisfiable?Number.MAX_VALUE:this.right.scale*this.right.position()-this.gap-this.left.scale*this.left.position()}}class g{constructor(t,e=1,s=1){this.desiredPosition=t,this.weight=e,this.scale=s,this.offset=0,this.cIn=[],this.cOut=[]}dfdv(){return 2*this.weight*(this.position()-this.desiredPosition)}position(){return(this.block.ps.scale*this.block.posn+this.offset)/this.scale}visitNeighbours(t,e){const s=(s,n)=>{s.active&&t!==n&&e(s,n)};this.cOut.forEach(t=>s(t,t.right)),this.cIn.forEach(t=>s(t,t.left))}}class v{constructor(t){this.vars=[],t.offset=0,this.ps=new p(t.scale),this.posn=0,this.addVariable(t)}addVariable(t){t.block=this,this.vars.push(t),this.ps.addVariable(t),this.posn=this.ps.getPosn()}updateWeightedPosition(){this.ps.AB=this.ps.AD=this.ps.A2=0;for(let t=0,e=this.vars.length;t{const r=this.compute_lm(i,t,s);i===e.right?(n+=r*e.left.scale,e.lm=r):(n+=r*e.right.scale,e.lm=-r),s(e)}),n/t.scale}populateSplitBlock(t,e){t.visitNeighbours(e,(e,s)=>{s.offset=t.offset+(s===e.right?e.gap:-e.gap),this.addVariable(s),this.populateSplitBlock(s,t)})}traverse(t,e,s=this.vars[0],n=null){s.visitNeighbours(n,(n,i)=>{e.push(t(n)),this.traverse(t,e,i,s)})}findMinLM(){let t=null;return this.compute_lm(this.vars[0],null,e=>{!e.equality&&(null===t||e.lm{});let s=null;return this.findPath(t,null,e,(t,e)=>{!t.equality&&t.right===e&&(null===s||t.lm{i||r!==s&&!this.findPath(r,t,s,n)||(i=!0,n(e,r))}),i}isActiveDirectedPathBetween(t,e){if(t===e)return!0;let s=t.cOut.length;for(;s--;){const n=t.cOut[s];if(n.active&&this.isActiveDirectedPathBetween(n.right,e))return!0}return!1}static split(t){return t.active=!1,[v.createSplitBlock(t.left),v.createSplitBlock(t.right)]}static createSplitBlock(t){const e=new v(t);return e.populateSplitBlock(t,null),e}splitBetween(t,e){const s=this.findMinLMBetween(t,e);if(null!==s){const t=v.split(s);return{constraint:s,lb:t[0],rb:t[1]}}return null}mergeAcross(t,e,s){e.active=!0;for(let e=0,n=t.vars.length;et.updateWeightedPosition())}split(t){this.updateBlockPositions(),this.list.forEach(e=>{const s=e.findMinLM();if(null!==s&&s.lmthis.insert(t)),this.remove(e),t.push(s)}})}}class P{constructor(t,e){this.vs=t,this.cs=e,t.forEach(t=>{t.cIn=[],t.cOut=[]}),e.forEach(t=>{t.left.cOut.push(t),t.right.cIn.push(t)}),this.inactive=e.map(t=>(t.active=!1,t)),this.bs=null}cost(){return this.bs.cost()}setStartingPositions(t){this.inactive=this.cs.map(t=>(t.active=!1,t)),this.bs=new b(this.vs),this.bs.forEach((e,s)=>{e.posn=t[s]})}setDesiredPositions(t){this.vs.forEach((e,s)=>{e.desiredPosition=t[s]})}mostViolated(){let t=Number.MAX_VALUE,e=null;const s=this.inactive,n=s.length;let i=n;for(let r=0;r=0?this.inactive.push(t):this.bs.merge(t)}}}solve(){this.satisfy();let t=Number.MAX_VALUE,e=this.bs.cost();for(;Math.abs(t-e)>1e-4;)this.satisfy(),t=e,e=this.bs.cost();return e}}P.LAGRANGIAN_TOLERANCE=-1e-4,P.ZERO_UPPERBOUND=-1e-10;const y={lineSpacing:2,nodeSpacing:3,minPos:0,maxPos:null};function w(t){var e;const s=new g(null!==(e=t.targetPos)&&void 0!==e?e:t.idealPos);return s.node=t,s}function E(t,e){if(t.length>0){const s=o.extend({},y,null!=e?e:{});t.forEach((t,e)=>{t.targetPos=t.parent?t.parent.currentPos:t.idealPos,t.index=e});const n=t.concat().sort((t,e)=>{var s,n,i,r;const o=(null!==(s=t.targetPos)&&void 0!==s?s:0)-(null!==(n=e.targetPos)&&void 0!==n?n:0);if(0!==o)return o;const h=(t.isStub()?1:0)-(e.isStub()?1:0);return 0!==h?h:(null!==(i=t.index)&&void 0!==i?i:0)-(null!==(r=e.index)&&void 0!==r?r:0)}).map(w),i=[];for(let t=1;t!!t.node).forEach(t=>{t.node.currentPos=Math.round(t.position())})}return t}E.DEFAULT_OPTIONS=y;const x={nodeSpacing:3,minPos:0,maxPos:null,algorithm:"overlap",removeOverlap:!0,density:.85,stubWidth:1,lineSpacing:2};const A=function(t){const e={};let s={...x};const n=f();let i=[],r=null;return e.nodes=function(t){return arguments.length?(i=t,r=[t.concat()],e):i},e.getLayers=function(){return r},e.options=function(t){if(!arguments.length)return s;s=o.extend(s,t);const i=o.pick(s,Object.keys(f.DEFAULT_OPTIONS));return o.isDefined(s.minPos)&&o.isDefined(s.maxPos)?i.layerWidth=s.maxPos-s.minPos:i.layerWidth=null,n.options(i),e},e.options(null!=t?t:{}),e.compute=function(){const t=o.pick(s,Object.keys(E.DEFAULT_OPTIONS));return i.forEach(t=>t.removeStub()),r=n.distribute(i),r.forEach((e,n)=>{e.forEach(t=>{t.layerIndex=n}),s.removeOverlap&&E(e,t)}),e},e.start=function(){console.log("[warning] force.start() is deprecated. Please use force.compute() instead.")},e};function O(t){return"L "+t.join(" ")}function S(t){return"M "+t.join(" ")}function _(t,e,s){return"C "+t.join(" ")+" "+e.join(" ")+" "+s.join(" ")}function k(t,e){const s=(t[1]+e[1])/2;return _([t[0],s],[e[0],s],e)}function L(t,e){const s=(t[0]+e[0])/2;return _([s,t[1]],[s,e[1]],e)}A.DEFAULT_OPTIONS=x;class I{constructor(t){this.options=o.extend({layerGap:60,nodeHeight:10,direction:"down"},null!=t?t:{})}getWaypoints(t){const{nodeHeight:e,layerGap:s,direction:n}=this.options,i=t.getPathFromRoot(),r=e+s;return"left"===n?[[[0,i[0].idealPos]]].concat(i.map((t,s)=>{const n=r*(s+1)*-1;return[[n+e,t.currentPos],[n,t.currentPos]]})):"right"===n?[[[0,i[0].idealPos]]].concat(i.map((t,s)=>{const n=r*(s+1);return[[n-e,t.currentPos],[n,t.currentPos]]})):"up"===n?[[[i[0].idealPos,0]]].concat(i.map((t,s)=>{const n=r*(s+1)*-1;return[[t.currentPos,n+e],[t.currentPos,n]]})):[[[i[0].idealPos,0]]].concat(i.map((t,s)=>{const n=r*(s+1);return[[t.currentPos,n-e],[t.currentPos,n]]}))}layout(t){const{layerGap:e,nodeHeight:s,direction:n}=this.options,i=e+s;switch(n){case"left":t.forEach(t=>{const n=t.getLayerIndex()*i+e;t.x=-n-s,t.y=t.currentPos,t.dx=s,t.dy=t.width});break;case"right":t.forEach(t=>{const n=t.getLayerIndex()*i+e;t.x=n,t.y=t.currentPos,t.dx=s,t.dy=t.width});break;case"up":t.forEach(t=>{const n=t.getLayerIndex()*i+e;t.x=t.currentPos,t.y=-n-s,t.dx=t.width,t.dy=s});break;default:t.forEach(t=>{const n=t.getLayerIndex()*i+e;t.x=t.currentPos,t.y=n,t.dx=t.width,t.dy=s})}return t}generatePath(t){const{direction:e}=this.options,s=this.getWaypoints(t),n=[S(s[0][0])];return"left"===e||"right"===e?s.reduce((t,e,i)=>(n.push(L(t[t.length-1],e[0])),i(n.push(k(t[t.length-1],e[0])),it.filter(t=>!t.isStub()).length)}I.lineTo=O,I.moveTo=S,I.curveTo=_,I.vCurveBetween=k,I.hCurveBetween=L;const T={displacement(t){if(0===t.length)return 0;const e=R(t);return o.sum(e,t=>o.sum(t,t=>t.isStub()?0:Math.abs(t.displacement())))/D(e)},pathLength(t){if(0===t.length)return 0;const e=R(t);return o.sum(e,t=>o.sum(t,t=>t.isStub()?0:Math.abs(t.getPathToRootLength())))/D(e)},overflowSpace(t,e,s){if(0===t.length||!o.isDefined(e)&&!o.isDefined(s))return 0;const n=R(t);return o.sum(n,t=>o.sum(t,t=>{const n=t.currentLeft(),i=t.currentRight();if(o.isDefined(e)&&null!=e){if(i<=e)return t.width;if(n=s)return t.width;if(i>s)return i-s}return 0}))},overDensitySpace(t,e,s,n=0){if(0===t.length||!o.isDefined(e)||!o.isDefined(s))return 0;const i=e*s,r=R(t);return o.sum(r,t=>{const e=o.sum(t,t=>t.width+n)-n;return e<=i?0:e-i})},overlapCount(t,e){if(0===t.length)return 0;const s=R(t);return o.sum(s,t=>{let s=0;for(let n=0;n{let e=0;for(let s=0;st.length)}(e)},weightedAllocation(t){if(0===t.length)return 0;const e=R(t);return o.sum(e,(t,e)=>e*t.filter(t=>!t.isStub()).length)},weightedAllocatedSpace(t){if(0===t.length)return 0;const e=R(t);return o.sum(e,(t,e)=>e*o.sum(t,t=>t.width))}},W={generateNodes(t,s){const n=[],i=o.extend({},{minWidth:20,maxWidth:20,minPos:0,maxPos:800},null!=s?s:{}),r=i.maxPos-i.minPos,h=i.maxWidth-i.minWidth;for(let s=0;s, ...sources: unknown[]): Record; +declare function extend(target: Record, ...sources: unknown[]): Record; +export default extend; diff --git a/dist/lib/intervalTree.d.ts b/dist/lib/intervalTree.d.ts new file mode 100644 index 0000000..3de134d --- /dev/null +++ b/dist/lib/intervalTree.d.ts @@ -0,0 +1,40 @@ +import SortedList from './sortedList.js'; +export interface IntervalResult { + id: number; + data: IntervalData; + rate1?: number; + rate2?: number; +} +export type IntervalData = [number, number, ...unknown[]]; +interface IntervalRecord { + id: number; + start: number; + end: number; + data: IntervalData; + result(start?: number, end?: number): IntervalResult; +} +interface TreeNode { + idx: number; + left?: TreeNode; + right?: TreeNode; + starts: SortedList; + ends: SortedList; + insert(interval: IntervalRecord): void; +} +declare class IntervalTree { + startKey: number; + endKey: number; + intervalHash: Record; + pointTree: SortedList<[number, number]>; + _autoIncrement: number; + root: TreeNode; + constructor(center: number, options?: { + startKey?: number; + endKey?: number; + }); + add(data: IntervalData, id?: number): void; + search(val1: number, val2?: number): IntervalResult[]; + remove(_intervalId: number): void; + private _rangeSearch; +} +export default IntervalTree; diff --git a/dist/lib/sortedList.d.ts b/dist/lib/sortedList.d.ts new file mode 100644 index 0000000..8485676 --- /dev/null +++ b/dist/lib/sortedList.d.ts @@ -0,0 +1,28 @@ +export type CompareFunction = (a: T | null, b: T | null) => number; +export interface SortedListOptions { + compare?: CompareFunction | keyof typeof SortedList.compares; + filter?: (val: T, pos: number) => boolean; + unique?: boolean; + resume?: boolean; +} +declare class SortedList extends Array { + _compare: CompareFunction; + _unique: boolean; + _filter: (val: T, pos: number) => boolean; + static compares: { + number: CompareFunction; + string: CompareFunction; + }; + static create(options?: SortedListOptions): SortedList; + static create(arr: T[], options?: SortedListOptions): SortedList; + constructor(arr?: T[] | SortedListOptions, options?: SortedListOptions); + insertOne(val: T): number | false; + insert(...vals: T[]): (number | false)[]; + remove(pos: number): this; + bsearch(val: T): number; + key(val: T, bsResult?: number): number | null; + searchKeys(val: T, bsResult?: number): number[] | null; + unique(createNew?: boolean): SortedList | T[]; + toArray(): T[]; +} +export default SortedList; diff --git a/dist/lib/vpsc.d.ts b/dist/lib/vpsc.d.ts new file mode 100644 index 0000000..fa2734f --- /dev/null +++ b/dist/lib/vpsc.d.ts @@ -0,0 +1,87 @@ +declare class PositionStats { + scale: number; + AB: number; + AD: number; + A2: number; + constructor(scale: number); + addVariable(v: Variable): void; + getPosn(): number; +} +export declare class Constraint { + left: Variable; + right: Variable; + gap: number; + equality: boolean; + active: boolean; + unsatisfiable: boolean; + lm: number; + constructor(left: Variable, right: Variable, gap: number, equality?: boolean); + slack(): number; +} +export declare class Variable { + desiredPosition: number; + weight: number; + scale: number; + offset: number; + block: Block; + cIn: Constraint[]; + cOut: Constraint[]; + [key: string]: unknown; + constructor(desiredPosition: number, weight?: number, scale?: number); + dfdv(): number; + position(): number; + visitNeighbours(prev: Variable | null, f: (c: Constraint, next: Variable) => void): void; +} +declare class Block { + vars: Variable[]; + ps: PositionStats; + posn: number; + blockInd: number; + constructor(v: Variable); + addVariable(v: Variable): void; + updateWeightedPosition(): void; + compute_lm(v: Variable, u: Variable | null, postAction: (c: Constraint) => void): number; + populateSplitBlock(v: Variable, prev: Variable | null): void; + traverse(visit: (c: Constraint) => unknown, acc: unknown[], v?: Variable, prev?: Variable | null): void; + findMinLM(): Constraint | null; + findMinLMBetween(lv: Variable, rv: Variable): Constraint | null; + findPath(v: Variable, prev: Variable | null, to: Variable, visit: (c: Constraint, next: Variable) => void): boolean; + isActiveDirectedPathBetween(u: Variable, v: Variable): boolean; + static split(c: Constraint): [Block, Block]; + static createSplitBlock(startVar: Variable): Block; + splitBetween(vl: Variable, vr: Variable): { + constraint: Constraint; + lb: Block; + rb: Block; + } | null; + mergeAcross(b: Block, c: Constraint, dist: number): void; + cost(): number; +} +declare class Blocks { + vs: Variable[]; + list: Block[]; + constructor(vs: Variable[]); + cost(): number; + insert(b: Block): void; + remove(b: Block): void; + merge(c: Constraint): void; + forEach(f: (b: Block, i: number) => void): void; + updateBlockPositions(): void; + split(inactive: Constraint[]): void; +} +export declare class Solver { + vs: Variable[]; + cs: Constraint[]; + inactive: Constraint[]; + bs: Blocks | null; + static LAGRANGIAN_TOLERANCE: number; + static ZERO_UPPERBOUND: number; + constructor(vs: Variable[], cs: Constraint[]); + cost(): number; + setStartingPositions(ps: number[]): void; + setDesiredPositions(ps: number[]): void; + mostViolated(): Constraint | null; + satisfy(): void; + solve(): number; +} +export {}; diff --git a/examples/basic_down.html b/examples/basic_down.html index 5657f9a..68e5ccc 100644 --- a/examples/basic_down.html +++ b/examples/basic_down.html @@ -4,7 +4,7 @@ Labella.js - + @@ -46,8 +46,8 @@

Labels should be beautiful.

Copyright 2015 Twitter, Inc. Licensed under Apache 2.0 License - - + + - + + - + + - + + - - - + + + + diff --git a/examples/with_text.html b/examples/with_text.html index 3a9a19a..4691661 100644 --- a/examples/with_text.html +++ b/examples/with_text.html @@ -4,7 +4,7 @@ Labella.js - + @@ -46,8 +46,8 @@

Labels should be beautiful.

Copyright 2015 Twitter, Inc. Licensed under Apache 2.0 License - - + + - + +