@live-change/flatten-interval-tree 0.8.26

package/docs/styles/prettify-jsdoc.css

@@ -0,0 +1,111 @@
+/* JSDoc prettify.js theme */
+
+/* plain text */
+.pln {
+  color: #000000;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* string content */
+.str {
+  color: hsl(104, 100%, 24%);
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a keyword */
+.kwd {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* a comment */
+.com {
+  font-weight: normal;
+  font-style: italic;
+}
+
+/* a type name */
+.typ {
+  color: #000000;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a literal value */
+.lit {
+  color: #006400;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* punctuation */
+.pun {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* lisp open bracket */
+.opn {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* lisp close bracket */
+.clo {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* a markup tag name */
+.tag {
+  color: #006400;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a markup attribute name */
+.atn {
+  color: #006400;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a markup attribute value */
+.atv {
+  color: #006400;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a declaration */
+.dec {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* a variable name */
+.var {
+  color: #000000;
+  font-weight: normal;
+  font-style: normal;
+}
+
+/* a function name */
+.fun {
+  color: #000000;
+  font-weight: bold;
+  font-style: normal;
+}
+
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums {
+  margin-top: 0;
+  margin-bottom: 0;
+}

package/docs/styles/prettify-tomorrow.css

@@ -0,0 +1,132 @@
+/* Tomorrow Theme */
+/* Original theme - https://github.com/chriskempson/tomorrow-theme */
+/* Pretty printing styles. Used with prettify.js. */
+/* SPAN elements with the classes below are added by prettyprint. */
+/* plain text */
+.pln {
+  color: #4d4d4c; }
+
+@media screen {
+  /* string content */
+  .str {
+    color: hsl(104, 100%, 24%); }
+
+  /* a keyword */
+  .kwd {
+    color: hsl(240, 100%, 50%); }
+
+  /* a comment */
+  .com {
+    color: hsl(0, 0%, 60%); }
+
+  /* a type name */
+  .typ {
+    color: hsl(240, 100%, 32%); }
+
+  /* a literal value */
+  .lit {
+    color: hsl(240, 100%, 40%); }
+
+  /* punctuation */
+  .pun {
+    color: #000000; }
+
+  /* lisp open bracket */
+  .opn {
+    color: #000000; }
+
+  /* lisp close bracket */
+  .clo {
+    color: #000000; }
+
+  /* a markup tag name */
+  .tag {
+    color: #c82829; }
+
+  /* a markup attribute name */
+  .atn {
+    color: #f5871f; }
+
+  /* a markup attribute value */
+  .atv {
+    color: #3e999f; }
+
+  /* a declaration */
+  .dec {
+    color: #f5871f; }
+
+  /* a variable name */
+  .var {
+    color: #c82829; }
+
+  /* a function name */
+  .fun {
+    color: #4271ae; } }
+/* Use higher contrast and text-weight for printable form. */
+@media print, projection {
+  .str {
+    color: #060; }
+
+  .kwd {
+    color: #006;
+    font-weight: bold; }
+
+  .com {
+    color: #600;
+    font-style: italic; }
+
+  .typ {
+    color: #404;
+    font-weight: bold; }
+
+  .lit {
+    color: #044; }
+
+  .pun, .opn, .clo {
+    color: #440; }
+
+  .tag {
+    color: #006;
+    font-weight: bold; }
+
+  .atn {
+    color: #404; }
+
+  .atv {
+    color: #060; } }
+/* Style */
+/*
+pre.prettyprint {
+  background: white;
+  font-family: Consolas, Monaco, 'Andale Mono', monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  border: 1px solid #ccc;
+  padding: 10px; }
+*/
+
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums {
+  margin-top: 0;
+  margin-bottom: 0; }
+
+/* IE indents via margin-left */
+li.L0,
+li.L1,
+li.L2,
+li.L3,
+li.L4,
+li.L5,
+li.L6,
+li.L7,
+li.L8,
+li.L9 {
+  /* */ }
+
+/* Alternate shading for lines */
+li.L1,
+li.L3,
+li.L5,
+li.L7,
+li.L9 {
+  /* */ }

package/examples/browser/index.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>Browser</title>
+    <script src='https://unpkg.com/@flatten-js/interval-tree'></script>
+</head>
+<body>
+    <div id="main">
+        <h2>Great composers</h2>
+        <ul id="list" style="list-style: none">
+
+        </ul>
+        <h2>Composers who lived in 17th century</h2>
+        <ul id="results" style="list-style: none">
+
+        </ul>
+    </div>
+<script>
+    const IntervalTree = window["@flatten-js/interval-tree"].default;
+    const composers = [
+        {name: "Ludwig van Beethoven", period: [1770,1827]},
+        {name: "Johann Sebastian Bach", period: [1685, 1750]},
+        {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+        {name: "Johannes Brahms", period: [1833, 1897]},
+        {name: "Richard Wagner", period: [1813, 1883]},
+        {name: "Claude Debussy", period: [1862, 1918]},
+        {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+        {name: "Frédéric Chopin", period: [1810, 1849]},
+        {name: "Joseph Haydn", period: [1732, 1809]},
+        {name: "Antonio Vivaldi", period: [1678, 1741]}
+    ];
+
+    const compList = composers.reduce( (html,composer) => html + `<li>${composer.name} (${composer.period[0]} - ${composer.period[1]})</li>`, "" );
+    document.getElementById("list").innerHTML = compList;
+
+    // Composers who lived in 17th century
+    const tree = new IntervalTree();
+    for (let composer of composers)
+        tree.insert(composer.period, composer.name);
+
+    const searchRes = tree.search( [1600,1700], (name, period) => {return {name : name, period: period.output()}} );
+
+    const resList = searchRes.reduce( (html, composer) => html + `<li>${composer.name} (${composer.period[0]} - ${composer.period[1]})</li>`, "" );
+    document.getElementById("results").innerHTML = resList;
+
+</script>
+</body>
+</html>

package/examples/create-react-app/package.json

@@ -0,0 +1,15 @@
+{
+  "private": true,
+  "name": "flatten-react-app",
+  "main": "src/index.js",
+  "scripts": {
+    "build": "react-scripts build",
+    "start": "react-scripts start"
+  },
+  "devDependencies": {
+    "react-scripts": "*"
+  },
+  "dependencies": {
+    "@flatten-js/interval-tree": "*"
+  }
+}

package/examples/create-react-app/public/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>React App</title>
+</head>
+<body>
+    <div id="root">
+    </div>
+</body>
+</html>

package/examples/create-react-app/src/App.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import IntervalTree from "@flatten-js/interval-tree";
+import ComposersList from './ComposersList';
+
+const composers = [
+    {name: "Ludwig van Beethoven", period: [1770, 1827]},
+    {name: "Johann Sebastian Bach", period: [1685, 1750]},
+    {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+    {name: "Johannes Brahms", period: [1833, 1897]},
+    {name: "Richard Wagner", period: [1813, 1883]},
+    {name: "Claude Debussy", period: [1862, 1918]},
+    {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+    {name: "Frédéric Chopin", period: [1810, 1849]},
+    {name: "Joseph Haydn", period: [1732, 1809]},
+    {name: "Antonio Vivaldi", period: [1678, 1741]}
+];
+
+const tree = new IntervalTree();
+for (let composer of composers)
+    tree.insert(composer.period, composer.name);
+
+const searchRes = tree.search([1600, 1700], (name, period) => {
+    return {name: name, period: period.output()}
+});
+
+const App = (title, filter) => {
+    return (
+        <div>
+            <h2>Great composers</h2>
+            <ComposersList composers={composers}/>
+
+            <h2>Composers who lived in 17th century</h2>
+            <ComposersList composers={searchRes}/>
+        </div>
+    );
+};
+
+export default App;

package/examples/create-react-app/src/ComposersList.js

@@ -0,0 +1,15 @@
+import React from 'react';
+
+const ComposersList = ({composers}) => {
+    return (
+        <ul style={{listStyle: "none"}}>
+            {composers.map( composer =>
+                <li key={composer.name}>
+                    {composer.name} ({composer.period[0]} - {composer.period[1]})
+                </li>
+            )}
+        </ul>
+    );
+};
+
+export default ComposersList;

package/examples/create-react-app/src/index.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import App from './App';
+
+ReactDOM.render(<App />, document.getElementById('root'));

package/examples/es6-module/index.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <!-- ALl credits to Turf https://github.com/Turfjs/turf/blob/master/examples/es-modules/index.html -->
+    <title>ES Modules</title>
+</head>
+<body>
+    <div id="main">
+        <h2>Great composers</h2>
+        <ul id="list" style="list-style: none">
+
+        </ul>
+        <h2>Composers who lived in 17th century</h2>
+        <ul id="results" style="list-style: none">
+
+        </ul>
+    </div>
+
+    <script type="module">
+        import IntervalTree from "https://unpkg.com/@flatten-js/interval-tree?module";
+
+        const composers = [
+            {name: "Ludwig van Beethoven", period: [1770,1827]},
+            {name: "Johann Sebastian Bach", period: [1685, 1750]},
+            {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+            {name: "Johannes Brahms", period: [1833, 1897]},
+            {name: "Richard Wagner", period: [1813, 1883]},
+            {name: "Claude Debussy", period: [1862, 1918]},
+            {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+            {name: "Frédéric Chopin", period: [1810, 1849]},
+            {name: "Joseph Haydn", period: [1732, 1809]},
+            {name: "Antonio Vivaldi", period: [1678, 1741]}
+        ];
+
+        const compList = composers.reduce( (html,composer) => html + `<li>${composer.name} (${composer.period[0]} - ${composer.period[1]})</li>`, "" );
+        document.getElementById("list").innerHTML = compList;
+
+        // Composers who lived in 17th century
+        const tree = new IntervalTree();
+        for (let composer of composers)
+            tree.insert(composer.period, composer.name);
+
+        const searchRes = tree.search( [1600,1700], (name, period) => {return {name : name, period: period.output()}} );
+
+        const resList = searchRes.reduce( (html, composer) => html + `<li>${composer.name} (${composer.period[0]} - ${composer.period[1]})</li>`, "" );
+        document.getElementById("results").innerHTML = resList;
+    </script>
+</body>
+</html>

package/examples/nodejs/index.js

@@ -0,0 +1,23 @@
+const IntervalTree = require("@flatten-js/interval-tree").default;
+
+const composers = [
+    {name: "Ludwig van Beethoven", period: [1770,1827]},
+    {name: "Johann Sebastian Bach", period: [1685, 1750]},
+    {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+    {name: "Johannes Brahms", period: [1833, 1897]},
+    {name: "Richard Wagner", period: [1813, 1883]},
+    {name: "Claude Debussy", period: [1862, 1918]},
+    {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+    {name: "Frédéric Chopin", period: [1810, 1849]},
+    {name: "Joseph Haydn", period: [1732, 1809]},
+    {name: "Antonio Vivaldi", period: [1678, 1741]}
+];
+
+// Composers who lived in 17th century
+const tree = new IntervalTree();
+for (let composer of composers)
+    tree.insert(composer.period, composer.name);
+
+const searchRes = tree.search( [1600,1700], (name, period) => {return {name : name, period: period.output()}} );
+
+console.log(searchRes);

package/index.d.ts

@@ -0,0 +1,65 @@
+// Type definitions for flatten-interval-tree library v1.0.2
+// Project: https://github.com/alexbol99/flatten-js
+// Definitions by: Alex Bol
+
+type Comparable = any;      // any object that implements operators '<' and '==' and  method'max'
+type Value = any;
+
+declare class Interval {
+    low: Comparable;
+    high: Comparable;
+
+    readonly  max: Interval;
+
+    clone(): Interval;
+    less_than(other_interval: Interval) : boolean;
+    equal_to(other_interval: Interval) : boolean;
+    intersect(other_interval: Interval) : boolean;
+    not_intersect(other_interval: Interval) : boolean;
+    merge(other_interval: Interval) : Interval;
+    output() : [number, number];
+
+    static comparable_max(arg1: Interval, arg2: Interval) : Interval;
+    static comparable_less_than(arg1: Comparable, arg2: Comparable ) : boolean;
+}
+
+type Item = {key: Interval, value: Value}
+
+declare class Node {
+    constructor(key?: Interval | number[], value?: Value )
+
+    left: Node;
+    right: Node;
+    parent: Node;
+    color: 1 | 0;
+    item: Item;
+
+    isNil() : boolean;
+    less_than(other_node: Node) : boolean;
+    equal_to(other_node: Node) : boolean;
+    intersect(other_node: Node) : boolean;
+    copy_data(other_node: Node) : void;
+    update_max() : void;
+}
+
+declare class IntervalTree {
+    constructor()
+
+    root: Node;
+
+    readonly size: number;
+    readonly keys: Node[];
+    readonly values: Value[];
+    readonly items: Array<{key:Interval, value:Value}>;
+
+    isEmpty(): boolean;
+    insert(key: Interval | number[], value?: Value) : Node;
+    exist(key: Interval | number[], value?: Value): boolean;
+    remove(key: Interval | number[], value?: Value) : Node;
+    search(interval: Interval | number[], outputMapperFn?: (value: Value, key: Interval) => any) : Array<any>;
+    forEach(callbackfn: (key: Interval, value: Value) => void, thisArg?: any ) : void;
+    map(callbackFn: (value: Value, key?: Interval) => any, thisArg?: any ): IntervalTree;
+}
+
+export default IntervalTree;
+

package/index.js

@@ -0,0 +1,6 @@
+export {default as Node} from './src/classes/node';
+export {default as Interval} from './src/classes/interval';
+// export {default as IntervalTree} from './src/classes/intervalTree.js';
+import IntervalTree from './src/classes/intervalTree.js';
+export default IntervalTree;
+

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@live-change/flatten-interval-tree",
+  "version": "0.8.26",
+  "description": "Interval search tree - this is a fork of the original project that support strings as keys.",
+  "author": "Michał Łaszczewski <michal@lasczewski.pl>",
+  "contributors": [
+    {
+      "name": "Alex",
+      "email": "alexbol99@gmail.com"
+    }
+  ],
+  "license": "MIT",
+  "main": "dist/main.cjs.js",
+  "umd:main": "dist/main.umd.js",
+  "unpkg": "dist/main.umd.js",
+  "module": "dist/main.esm.js",
+  "types": "index.d.ts",
+  "nyc": {
+    "require": [
+      "@babel/register"
+    ],
+    "sourceMap": false,
+    "instrument": false
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "test": "nyc --reporter=html --reporter=text mocha --exit",
+    "generate-docs": "jsdoc -t ./node_modules/minami -d ./docs ./src -r README.md",
+    "coverage": "nyc report --reporter=text-lcov | coveralls",
+    "publish-npm": "npm publish --access public"
+  },
+  "keywords": [
+    "interval tree",
+    "binary search tree"
+  ],
+  "devDependencies": {
+    "@babel/cli": "^7.2.3",
+    "@babel/core": "^7.2.2",
+    "@babel/node": "^7.2.2",
+    "@babel/preset-env": "^7.3.1",
+    "@babel/register": "^7.0.0",
+    "babel-plugin-istanbul": "^5.1.1",
+    "chai": "^3.5.0",
+    "coveralls": "^3.0.3",
+    "jsdoc": "^3.6.2",
+    "minami": "^1.2.3",
+    "mocha": "^5.2.0",
+    "nyc": "^14.1.1",
+    "rollup": "^1.6.0"
+  },
+  "gitHead": "e62696aa9fa6e5b86312dfb64c97efa300d41147"
+}

package/rollup.config.js

@@ -0,0 +1,21 @@
+export default {
+    input: 'index.js',
+    output: [
+        {
+            file: 'dist/main.cjs.js',
+            format: 'cjs',
+            exports: 'named'
+        },
+        {
+            file: 'dist/main.esm.js',
+            format: 'esm',
+            exports: 'named'
+        },
+        {
+            file: 'dist/main.umd.js',
+            format: 'umd',
+            exports: 'named',
+            name: '@flatten-js/interval-tree'
+        }
+    ]
+};