@formant/ava 3.4.1-formant

package/lib/data/dataset/field/series.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var utils_1 = require("../../utils");
+var utils_2 = require("./utils");
+var baseFrame_1 = tslib_1.__importDefault(require("./baseFrame"));
+/** 1D data structure */
+var Series = /** @class */ (function (_super) {
+    tslib_1.__extends(Series, _super);
+    function Series(data, extra) {
+        var _this = this;
+        var _a, _b, _c, _d;
+        _this = _super.call(this, data, extra) || this;
+        (0, utils_1.assert)((0, utils_1.isObject)(data) || (0, utils_1.isBasicType)(data) || (0, utils_1.isArray)(data), 'Data type is illegal');
+        /* 1D: object */
+        if ((0, utils_1.isObject)(data)) {
+            // generate indexes
+            var indexes = Object.keys(data);
+            if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                (0, utils_1.assert)(((_a = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _a === void 0 ? void 0 : _a.length) <= indexes.length, "Index length ".concat((_b = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _b === void 0 ? void 0 : _b.length, " is greater than data size ").concat(indexes.length));
+                for (var i = 0; i < (extra === null || extra === void 0 ? void 0 : extra.indexes.length); i += 1) {
+                    var idx = extra === null || extra === void 0 ? void 0 : extra.indexes[i];
+                    if (indexes.includes(idx)) {
+                        _this.data.push((0, utils_2.convertDataType)((0, utils_2.fillMissingValue)(data[idx], extra === null || extra === void 0 ? void 0 : extra.fillValue), (_c = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _c === void 0 ? void 0 : _c[0]));
+                    }
+                }
+                _this.setAxis(0, extra === null || extra === void 0 ? void 0 : extra.indexes);
+            }
+            else {
+                _this.data = Object.values(data).map(function (datum) { var _a; return (0, utils_2.convertDataType)((0, utils_2.fillMissingValue)(datum, extra === null || extra === void 0 ? void 0 : extra.fillValue), (_a = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _a === void 0 ? void 0 : _a[0]); });
+                _this.setAxis(0, indexes);
+            }
+        }
+        else if ((0, utils_1.isArray)(data)) {
+            /* 1D: array */
+            var _e = tslib_1.__read(data, 1), data0 = _e[0];
+            if (!(0, utils_1.isBasicType)(data0)) {
+                if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                    (0, utils_1.assert)(((_d = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _d === void 0 ? void 0 : _d.length) === data.length, "Index length is ".concat(extra === null || extra === void 0 ? void 0 : extra.indexes.length, ", but data size ").concat(data.length));
+                    _this.setAxis(0, extra === null || extra === void 0 ? void 0 : extra.indexes);
+                }
+                _this.data = data;
+            }
+        }
+        return _this;
+    }
+    Object.defineProperty(Series.prototype, "shape", {
+        get: function () {
+            return [this.axes[0].length];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Get data by row location and column location.
+     * @param rowLoc
+     */
+    Series.prototype.get = function (rowLoc) {
+        (0, utils_1.assert)((0, utils_1.isNumber)(rowLoc) ||
+            ((0, utils_1.isString)(rowLoc) && !rowLoc.includes(':')) ||
+            (0, utils_1.isArray)(rowLoc) ||
+            ((0, utils_1.isString)(rowLoc) && rowLoc.includes(':')), 'The rowLoc is illegal');
+        // input is like 0 || 'a'
+        if ((0, utils_1.isNumber)(rowLoc) || ((0, utils_1.isString)(rowLoc) && !rowLoc.includes(':'))) {
+            (0, utils_1.assert)(this.indexes.includes(rowLoc), 'The rowLoc is not found in the indexes.');
+            if ((0, utils_1.isNumber)(rowLoc)) {
+                return this.data[rowLoc];
+            }
+            if ((0, utils_1.isString)(rowLoc)) {
+                var rowIdx = this.indexes.indexOf(rowLoc);
+                return this.data[rowIdx];
+            }
+        }
+        if ((0, utils_1.isArray)(rowLoc)) {
+            // input is like [0, 1, 2] || ['a', 'b', 'c']
+            var newData = [];
+            var newIndex = [];
+            for (var i = 0; i < rowLoc.length; i += 1) {
+                var loc = rowLoc[i];
+                (0, utils_1.assert)(this.indexes.includes(loc), 'The rowLoc is not found in the indexes.');
+                var idxInIndex = this.indexes.indexOf(loc);
+                newData.push(this.data[idxInIndex]);
+                newIndex.push(this.indexes[idxInIndex]);
+            }
+            return new Series(newData, { indexes: newIndex });
+        }
+        if ((0, utils_1.isString)(rowLoc) && rowLoc.includes(':')) {
+            // input is like '0:2' || 'a:c'
+            var rowLocArr = rowLoc.split(':');
+            (0, utils_1.assert)(rowLocArr.length === 2, 'The rowLoc is not found in the indexes.');
+            var startLoc = rowLocArr[0];
+            var endLoc = rowLocArr[1];
+            if ((0, utils_1.isInteger)(Number(startLoc)) && (0, utils_1.isInteger)(Number(endLoc))) {
+                var startIdx = Number(startLoc);
+                var endIdx = Number(endLoc);
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+            if ((0, utils_1.isString)(startLoc) && (0, utils_1.isString)(endLoc)) {
+                var startIdx = this.indexes.indexOf(startLoc);
+                var endIdx = this.indexes.indexOf(endLoc);
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+        }
+        throw new Error('The rowLoc is illegal');
+    };
+    /**
+     * Get data by row location and column location using integer index.
+     * @param rowLoc
+     */
+    Series.prototype.getByIndex = function (rowLoc) {
+        (0, utils_1.assert)((0, utils_1.isInteger)(rowLoc) || (0, utils_1.isArray)(rowLoc) || ((0, utils_1.isString)(rowLoc) && rowLoc.includes(':')), 'The rowLoc is illegal');
+        // input is like 1
+        if ((0, utils_1.isInteger)(rowLoc)) {
+            (0, utils_1.assert)((0, utils_1.range)(this.indexes.length).includes(rowLoc), 'The rowLoc is not found in the indexes.');
+            if ((0, utils_1.range)(this.indexes.length).includes(rowLoc)) {
+                return this.data[rowLoc];
+            }
+        }
+        if ((0, utils_1.isArray)(rowLoc)) {
+            // input is like [0, 1, 2]
+            var newData = [];
+            var newIndex = [];
+            for (var i = 0; i < rowLoc.length; i += 1) {
+                var idx = rowLoc[i];
+                (0, utils_1.assert)((0, utils_1.range)(this.indexes.length).includes(idx), 'The rowLoc is not found in the indexes.');
+                newData.push(this.data[idx]);
+                newIndex.push(this.indexes[idx]);
+            }
+            return new Series(newData, { indexes: newIndex });
+        }
+        if ((0, utils_1.isString)(rowLoc) && rowLoc.includes(':')) {
+            // input is like '0:2'
+            var rowLocArr = rowLoc.split(':');
+            if (rowLocArr.length === 2) {
+                var startIdx = Number(rowLocArr[0]);
+                var endIdx = Number(rowLocArr[1]);
+                (0, utils_1.assert)((0, utils_1.isInteger)(startIdx) && (0, utils_1.isInteger)(endIdx), 'The rowLoc is not found in the indexes.');
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+        }
+        throw new Error('The rowLoc is illegal');
+    };
+    return Series;
+}(baseFrame_1.default));
+exports.default = Series;

package/lib/data/dataset/field/types.d.ts

@@ -0,0 +1,54 @@
+import type { StringFieldInfo, NumberFieldInfo, DateFieldInfo, FieldType } from '../../analysis/types';
+/**
+ * Array Type. One dimension or two dimension
+ * @public
+ */
+export type NDArray = unknown[] | unknown[][];
+/**
+ * One dimension series data.
+ * @public
+ */
+export type SeriesData = number | string | boolean | undefined | null | unknown[] | {
+    [key: string]: unknown;
+};
+/**
+ * One or two dimension frame data.
+ * @public
+ */
+export type FrameData = number | string | boolean | undefined | null | unknown[] | {
+    [key: string]: unknown;
+} | unknown[][] | {
+    [key: string]: unknown;
+}[] | {
+    [key: string]: unknown[];
+};
+/**
+ * Axis
+ * @public
+ */
+export type Axis = string | number;
+/**
+ * extra data configs
+ * @public
+ */
+export type Extra = {
+    indexes?: Axis[];
+    columns?: Axis[];
+    fillValue?: unknown;
+    /** When the columnType is empty, no data type is specified */
+    columnTypes?: (FieldType | '')[];
+    /**
+     * Whether only the main standard symbols recommended in ISO 8601 can be recognized as date fields, default is true.
+     * - Reference: https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+     * - For example, '202301' is recognized as a date string only when strictDatePattern is false.
+     * */
+    strictDatePattern?: boolean;
+};
+/**
+ * Fields Type
+ * @public
+ */
+export type FieldsInfo = Array<(StringFieldInfo | NumberFieldInfo | DateFieldInfo) & {
+    /** Field name */
+    name: string;
+}>;

package/lib/data/dataset/field/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/data/dataset/field/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Axis, Extra } from './types';
+export declare function isAxis(value: unknown): value is Axis;
+export declare function generateArrayIndex(data: unknown[], extraIndex?: Axis[]): Axis[];
+export declare function fillMissingValue(datum: unknown, fillValue: any): unknown;
+export declare function generateSplit(length: number): string;
+export declare function stringify(value: unknown): string;
+export declare function getStringifyLength(value: unknown): number;
+/**
+ * Convert data to specified data type.
+ * @param data
+ * @param type
+ */
+export declare function convertDataType(data: unknown, type: Extra['columnTypes'][number]): unknown;

package/lib/data/dataset/field/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDataType = exports.getStringifyLength = exports.stringify = exports.generateSplit = exports.fillMissingValue = exports.generateArrayIndex = exports.isAxis = void 0;
+var utils_1 = require("../../utils");
+function isAxis(value) {
+    return (0, utils_1.isNumber)(value) || (0, utils_1.isString)(value);
+}
+exports.isAxis = isAxis;
+// generate indexes for 1D and 2D array
+function generateArrayIndex(data, extraIndex) {
+    (0, utils_1.assert)((0, utils_1.isArray)(data), 'Data must be an array');
+    if (extraIndex) {
+        (0, utils_1.assert)((extraIndex === null || extraIndex === void 0 ? void 0 : extraIndex.length) === data.length, "Index length is ".concat(extraIndex === null || extraIndex === void 0 ? void 0 : extraIndex.length, ", but data size is ").concat(data.length));
+        return extraIndex;
+    }
+    return (0, utils_1.range)(data.length);
+}
+exports.generateArrayIndex = generateArrayIndex;
+function fillMissingValue(datum, fillValue) {
+    return !datum && JSON.stringify(fillValue) ? fillValue : datum;
+}
+exports.fillMissingValue = fillMissingValue;
+function generateSplit(length) {
+    return Array((0, utils_1.isNumber)(length) ? length : 0)
+        .fill(' ')
+        .concat('  ')
+        .join('');
+}
+exports.generateSplit = generateSplit;
+function stringify(value) {
+    var _a, _b, _c, _d, _e, _f;
+    return (((_f = (_e = (_d = (_c = (_b = (_a = JSON.stringify(value)) === null || _a === void 0 ? void 0 : _a.replace(/\\n/g, '')) === null || _b === void 0 ? void 0 : _b.replace(/\\/g, '')) === null || _c === void 0 ? void 0 : _c.replace(/"\[/g, '[')) === null || _d === void 0 ? void 0 : _d.replace(/\]"/g, ']')) === null || _e === void 0 ? void 0 : _e.replace(/"\{/g, '{')) === null || _f === void 0 ? void 0 : _f.replace(/\}"/g, ' }')) || 'undefined');
+}
+exports.stringify = stringify;
+function getStringifyLength(value) {
+    var _a;
+    return (_a = stringify(value)) === null || _a === void 0 ? void 0 : _a.length;
+}
+exports.getStringifyLength = getStringifyLength;
+/**
+ * Convert data to specified data type.
+ * @param data
+ * @param type
+ */
+function convertDataType(data, type) {
+    try {
+        if (type === 'string' && !(0, utils_1.isString)(data)) {
+            return "".concat(data);
+        }
+        if (type === 'boolean' && !(0, utils_1.isBoolean)(data)) {
+            return Boolean(data);
+        }
+        if (type === 'null' && !(0, utils_1.isNil)(data)) {
+            return null;
+        }
+        if ((type === 'integer' || type === 'float') && !(0, utils_1.isNumber)(data)) {
+            return +data;
+        }
+        if (type === 'date' && !(0, utils_1.isDate)(data) && ((0, utils_1.isNumber)(data) || (0, utils_1.isString)(data))) {
+            return new Date(data);
+        }
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+    return data;
+}
+exports.convertDataType = convertDataType;

package/lib/data/dataset/graph/index.d.ts

@@ -0,0 +1,18 @@
+import DataFrame from '../field/dataFrame';
+import type { GraphProps } from '../../analysis/graph/types';
+import type { NodeData, LinkData, GraphInput, GraphExtra } from './types';
+export default class GraphData {
+    private extra;
+    data: {
+        nodes: NodeData[];
+        links: LinkData[];
+    };
+    private autoParse;
+    constructor(data: GraphInput, extra?: GraphExtra);
+    getNodeFrame(): DataFrame;
+    getLinkFrame(): DataFrame;
+    /**
+     * Get statistics.
+     */
+    info(): GraphProps;
+}

package/lib/data/dataset/graph/index.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var analysis_1 = require("../../analysis");
+var graph_1 = require("../../analysis/graph");
+var field_1 = require("../../analysis/field");
+var utils_1 = require("../../utils");
+var dataFrame_1 = tslib_1.__importDefault(require("../field/dataFrame"));
+var utils_2 = require("./utils");
+/* eslint-disable no-param-reassign */
+function parseTreeNode(data, extra) {
+    var nodes = [];
+    var links = [];
+    var childrenKey = (extra === null || extra === void 0 ? void 0 : extra.childrenKey) || 'children';
+    var parseTree = function (treeNode) {
+        var children = treeNode[childrenKey] || [];
+        delete treeNode[childrenKey];
+        nodes === null || nodes === void 0 ? void 0 : nodes.push(treeNode);
+        for (var i = 0; i < children.length; i += 1) {
+            var item = children[i];
+            links === null || links === void 0 ? void 0 : links.push({
+                source: treeNode.id,
+                target: item.id,
+            });
+            parseTree(item);
+        }
+    };
+    parseTree(data);
+    return { nodes: nodes, links: links };
+}
+/**
+ * @param data link array
+ */
+function parseArray(data, extra) {
+    var _a = tslib_1.__read(data, 1), data0 = _a[0];
+    (0, utils_1.assert)((0, utils_1.isObject)(data0), 'Data is unable transform to graph');
+    var sourceKey = (extra === null || extra === void 0 ? void 0 : extra.sourceKey) || ('source' in data0 && 'source') || ('from' in data0 && 'from');
+    var targetKey = (extra === null || extra === void 0 ? void 0 : extra.targetKey) || ('target' in data0 && 'target') || ('to' in data0 && 'to');
+    var childrenKey = (extra === null || extra === void 0 ? void 0 : extra.childrenKey) || ('children' in data0 && 'children') || ('to' in data0 && 'to');
+    (0, utils_1.assert)(sourceKey || targetKey || childrenKey, 'Data is unable transform to graph');
+    var nodes = [];
+    var links = [];
+    var _b = data0, _c = sourceKey, source = _b[_c], _d = targetKey, target = _b[_d], _e = childrenKey, children = _b[_e];
+    if ((0, utils_1.isBasicType)(source) && (0, utils_1.isBasicType)(target)) {
+        var _loop_1 = function (i) {
+            var link = data[i];
+            var _g = link, _h = sourceKey, source_1 = _g[_h], _j = targetKey, target_1 = _g[_j];
+            if (nodes.findIndex(function (n) { return n.id === source_1; }) === -1) {
+                nodes.push({ id: source_1 });
+            }
+            if (nodes.findIndex(function (n) { return n.id === target_1; }) === -1) {
+                nodes.push({ id: target_1 });
+            }
+            var formatLink = tslib_1.__assign(tslib_1.__assign({}, link), { source: source_1, target: target_1 });
+            links.push(formatLink);
+        };
+        for (var i = 0; i < data.length; i += 1) {
+            _loop_1(i);
+        }
+    }
+    else if ((0, utils_1.isArray)(children)) {
+        // try to parse the array as multiple trees
+        for (var i = 0; i < data.length; i += 1) {
+            var tree = data[i];
+            var _f = parseTreeNode(tree, extra), subNodes = _f.nodes, subLinks = _f.links;
+            var _loop_2 = function (i_1) {
+                var node = subNodes[i_1];
+                var repeatNode = nodes.find(function (n) { return n.id === node.id; });
+                if (repeatNode) {
+                    repeatNode = tslib_1.__assign(tslib_1.__assign({}, node), repeatNode);
+                }
+                else {
+                    nodes.push(node);
+                }
+            };
+            for (var i_1 = 0; i_1 < subNodes.length; i_1 += 1) {
+                _loop_2(i_1);
+            }
+            links.push.apply(links, tslib_1.__spreadArray([], tslib_1.__read(subLinks), false));
+        }
+    }
+    return { nodes: nodes, links: links };
+}
+function isNodeArray(arr) {
+    if (!(0, utils_1.isArray)(arr) || arr.length <= 1)
+        return false;
+    var nodeIdInfo = (0, analysis_1.analyzeField)(arr.map(function (node) { return node.id; }));
+    return (0, field_1.isUnique)(nodeIdInfo);
+}
+function isValidNodeLinks(nodes, links) {
+    if (!(0, utils_1.isArray)(links) || !isNodeArray(nodes) || links.length <= 1)
+        return false;
+    var _loop_3 = function (i) {
+        var link = links[i];
+        var source = link.source, target = link.target;
+        var hasSourceNode = nodes.findIndex(function (item) { return item.id === source; });
+        var hasTargetNode = nodes.findIndex(function (item) { return item.id === target; });
+        if (!(hasSourceNode > -1 && hasTargetNode > -1)) {
+            return { value: false };
+        }
+    };
+    for (var i = 0; i < links.length; i += 1) {
+        var state_1 = _loop_3(i);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return true;
+}
+// TODO: The automatic parsing function has not been completed yet, for now, the GraphData constructor only accepts input data in several specified formats (see type GraphInput)
+var GraphData = /** @class */ (function () {
+    function GraphData(data, extra) {
+        this.data = {
+            nodes: [],
+            links: [],
+        };
+        this.extra = extra;
+        var _a = this.autoParse(data, extra), nodes = _a.nodes, links = _a.links;
+        (0, utils_1.assert)(isValidNodeLinks(nodes, links), 'Data is unable transform to graph');
+        this.data = {
+            nodes: nodes.map(function (node) { return (0, utils_2.flatObject)(node); }),
+            links: links.map(function (link) { return (0, utils_2.flatObject)(link); }),
+        };
+    }
+    GraphData.prototype.autoParse = function (data, extra) {
+        var nodes;
+        var links;
+        (0, utils_1.assert)((0, utils_1.isArray)(data) || (0, utils_1.isObject)(data), 'Data is unable transform to graph');
+        // try parse data as link array or multiple trees
+        if ((0, utils_1.isArray)(data)) {
+            var parsedData = parseArray(data, extra);
+            nodes = parsedData.nodes;
+            links = parsedData.links;
+        }
+        // if passed data tyoe is object
+        if ((0, utils_1.isObject)(data)) {
+            if ((extra === null || extra === void 0 ? void 0 : extra.nodeKey) && (extra === null || extra === void 0 ? void 0 : extra.linkKey)) {
+                nodes = data[extra.nodeKey];
+                links = data[extra.linkKey];
+            }
+            else if ((extra === null || extra === void 0 ? void 0 : extra.childrenKey) || 'children' in data) {
+                var parsedTree = parseTreeNode(data, extra);
+                nodes = parsedTree.nodes;
+                links = parsedTree.links;
+            }
+            else {
+                var nodeKey = 'nodes' in data && 'nodes';
+                var linkKey = ('links' in data && 'links') || ('edges' in data && 'edges');
+                nodes = data[nodeKey];
+                links = data[linkKey];
+            }
+        }
+        return { nodes: nodes, links: links };
+    };
+    GraphData.prototype.getNodeFrame = function () {
+        var _a, _b;
+        var extra = {
+            indexes: (_a = this.extra) === null || _a === void 0 ? void 0 : _a.nodeIndexes,
+            columns: (_b = this.extra) === null || _b === void 0 ? void 0 : _b.nodeColumns,
+        };
+        return new dataFrame_1.default(this.data.nodes, extra);
+    };
+    GraphData.prototype.getLinkFrame = function () {
+        var _a, _b;
+        var extra = {
+            indexes: (_a = this.extra) === null || _a === void 0 ? void 0 : _a.linkIndexes,
+            columns: (_b = this.extra) === null || _b === void 0 ? void 0 : _b.linkColumns,
+        };
+        return new dataFrame_1.default(this.data.links, extra);
+    };
+    /**
+     * Get statistics.
+     */
+    GraphData.prototype.info = function () {
+        var _a = this.data, nodes = _a.nodes, links = _a.links;
+        // calc fields statistics and structural statistics
+        var graphStructFeats = (0, graph_1.getAllStructFeats)(nodes, links);
+        var _b = (0, graph_1.getNodeFields)(nodes), nodeFields = _b.nodeFields, nodeFieldNames = _b.nodeFieldNames;
+        var _c = (0, graph_1.getLinkFields)(links), linkFields = _c.linkFields, linkFieldNames = _c.linkFieldNames;
+        var nodeFieldsInfo = (0, graph_1.getAllFieldsInfo)(nodeFields, nodeFieldNames);
+        var linkFieldsInfo = (0, graph_1.getAllFieldsInfo)(linkFields, linkFieldNames);
+        var getClusterField = (0, graph_1.clusterNodes)(nodes, nodeFieldsInfo, links);
+        nodeFieldsInfo.push(getClusterField);
+        var graphProps = tslib_1.__assign({ nodeFieldsInfo: nodeFieldsInfo, linkFieldsInfo: linkFieldsInfo }, graphStructFeats);
+        return graphProps;
+    };
+    return GraphData;
+}());
+exports.default = GraphData;

package/lib/data/dataset/graph/types.d.ts

@@ -0,0 +1,35 @@
+import type { Axis } from '../field/types';
+/**
+ * Graph extra info.
+ */
+export type GraphExtra = {
+    nodeKey?: string;
+    linkKey?: string;
+    sourceKey?: string;
+    targetKey?: string;
+    childrenKey?: string;
+    nodeIndexes?: Axis[];
+    nodeColumns?: Axis[];
+    linkIndexes?: Axis[];
+    linkColumns?: Axis[];
+};
+export type NodeData = {
+    id: string;
+    name?: string;
+    [key: string]: unknown;
+};
+export type LinkData = {
+    source: string;
+    target: string;
+    [key: string]: unknown;
+};
+export type GraphInput = TreeNode | {
+    [key: string]: unknown;
+}[] | {
+    [key: string]: unknown[];
+};
+export type TreeNode = {
+    id: string;
+    children: TreeNode[];
+    [key: string]: unknown;
+};

package/lib/data/dataset/graph/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/data/dataset/graph/utils.d.ts

@@ -0,0 +1 @@
+export declare function flatObject(obj: any, concatenator?: string): any;

package/lib/data/dataset/graph/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatObject = void 0;
+var tslib_1 = require("tslib");
+function flatObject(obj, concatenator) {
+    if (concatenator === void 0) { concatenator = '.'; }
+    return Object.keys(obj).reduce(function (acc, key) {
+        var _a;
+        if (typeof obj[key] !== 'object' || obj[key] === null) {
+            return tslib_1.__assign(tslib_1.__assign({}, acc), (_a = {}, _a[key] = obj[key], _a));
+        }
+        var flattenedChild = flatObject(obj[key], concatenator);
+        return tslib_1.__assign(tslib_1.__assign({}, acc), Object.keys(flattenedChild).reduce(function (childAcc, childKey) {
+            var _a;
+            return (tslib_1.__assign(tslib_1.__assign({}, childAcc), (_a = {}, _a["".concat(key).concat(concatenator).concat(childKey)] = flattenedChild[childKey], _a)));
+        }, {}));
+    }, {});
+}
+exports.flatObject = flatObject;

package/lib/data/dataset/index.d.ts

@@ -0,0 +1 @@
+export * from './field';

package/lib/data/dataset/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./field"), exports);

package/lib/data/dataset/types.d.ts

@@ -0,0 +1 @@
+export * from './field/types';

package/lib/data/dataset/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./field/types"), exports);

package/lib/data/index.d.ts

@@ -0,0 +1,5 @@
+export * from './analysis';
+export * from './dataset';
+export * from './statistics';
+export * from './utils';
+export * from './types';

package/lib/data/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./analysis"), exports);
+tslib_1.__exportStar(require("./dataset"), exports);
+tslib_1.__exportStar(require("./statistics"), exports);
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/lib/data/statistics/IQR.d.ts

@@ -0,0 +1,21 @@
+export interface IQRParams {
+    k: number;
+}
+interface IQRResult {
+    upper: {
+        threshold: number;
+        indexes: number[];
+    };
+    lower: {
+        threshold: number;
+        indexes: number[];
+    };
+}
+/**
+ *
+ * @param data
+ * @param params
+ * @returns
+ */
+export declare function IQR(data: number[], params?: IQRParams): IQRResult;
+export {};