@mwater/visualization 5.0.0

package/lib/layouts/blocks/DraggableBlockComponent.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importDefault(require("react"));
+const react_dom_1 = __importDefault(require("react-dom"));
+const R = react_1.default.createElement;
+const react_dnd_1 = require("react-dnd");
+// Block which can be dragged around in block layout.
+class DraggableBlockComponent extends react_1.default.Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            hoverSide: null
+        };
+    }
+    renderHover() {
+        const lineStyle = { position: "absolute" };
+        // Show
+        if (this.props.isOver) {
+            // style.backgroundColor = "#DDF"
+            switch (this.state.hoverSide) {
+                case "left":
+                    lineStyle.borderLeft = "solid 3px #38D";
+                    lineStyle.top = 0;
+                    lineStyle.bottom = 0;
+                    lineStyle.left = 0;
+                    break;
+                case "right":
+                    lineStyle.borderRight = "solid 3px #38D";
+                    lineStyle.top = 0;
+                    lineStyle.right = 0;
+                    lineStyle.bottom = 0;
+                    break;
+                case "top":
+                    lineStyle.borderTop = "solid 3px #38D";
+                    lineStyle.top = 0;
+                    lineStyle.left = 0;
+                    lineStyle.right = 0;
+                    break;
+                case "bottom":
+                    lineStyle.borderBottom = "solid 3px #38D";
+                    lineStyle.bottom = 0;
+                    lineStyle.left = 0;
+                    lineStyle.right = 0;
+                    break;
+            }
+            return R("div", { style: lineStyle });
+        }
+        else {
+            return null;
+        }
+    }
+    render() {
+        const style = {};
+        // Hide if dragging
+        if (this.props.isDragging) {
+            style.visibility = "hidden";
+        }
+        return this.props.connectDropTarget(R("div", { style: this.props.style }, R("div", { style: { position: "relative" } }, this.renderHover(), react_1.default.cloneElement(react_1.default.Children.only(this.props.children), {
+            connectMoveHandle: this.props.connectDragSource,
+            connectDragPreview: this.props.connectDragPreview
+        }))));
+    }
+}
+// Gets the drop side (top, left, right, bottom)
+function getDropSide(monitor, component) {
+    // Get underlying component
+    let pos;
+    const blockComponent = component.getDecoratedComponentInstance();
+    // Get bounds of component
+    const hoverBoundingRect = react_dom_1.default.findDOMNode(blockComponent).getBoundingClientRect();
+    const clientOffset = monitor.getClientOffset();
+    // Get position within hovered item
+    const hoverClientX = clientOffset.x - hoverBoundingRect.left;
+    const hoverClientY = clientOffset.y - hoverBoundingRect.top;
+    // Determine if over is more left, right, top or bottom
+    const fractionX = hoverClientX / (hoverBoundingRect.right - hoverBoundingRect.left);
+    const fractionY = hoverClientY / (hoverBoundingRect.bottom - hoverBoundingRect.top);
+    if (fractionX > fractionY) {
+        // top or right
+        if (1 - fractionX > fractionY) {
+            // top or left
+            pos = "top";
+        }
+        else {
+            pos = "right";
+        }
+    }
+    else {
+        // bottom or left
+        if (1 - fractionX > fractionY) {
+            // top or left
+            pos = "left";
+        }
+        else {
+            pos = "bottom";
+        }
+    }
+    return pos;
+}
+const blockTargetSpec = {
+    // Called when an block hovers over this component
+    hover(props, monitor, component) {
+        // Hovering over self does nothing
+        let side;
+        const hoveringId = monitor.getItem().block.id;
+        const myId = props.block.id;
+        if (hoveringId === myId) {
+            return;
+        }
+        if (props.onlyBottom) {
+            side = "bottom";
+        }
+        else {
+            side = getDropSide(monitor, component);
+        }
+        // Set the state
+        return component.getDecoratedComponentInstance().setState({ hoverSide: side });
+    },
+    canDrop(props, monitor) {
+        const hoveringId = monitor.getItem().block.id;
+        const myId = props.block.id;
+        if (hoveringId === myId) {
+            return false;
+        }
+        return true;
+    },
+    drop(props, monitor, component) {
+        if (monitor.didDrop()) {
+            return;
+        }
+        const side = component.getDecoratedComponentInstance().state.hoverSide;
+        props.onBlockDrop(monitor.getItem().block, props.block, side);
+    }
+};
+const blockSourceSpec = {
+    beginDrag(props, monitor, component) {
+        return {
+            block: props.block
+        };
+    },
+    isDragging(props, monitor) {
+        return props.block.id === monitor.getItem().block.id;
+    }
+};
+function collectTarget(connect, monitor) {
+    return {
+        connectDropTarget: connect.dropTarget(),
+        isOver: monitor.isOver({ shallow: true }),
+        canDrop: monitor.canDrop()
+    };
+}
+function collectSource(connect, monitor) {
+    return {
+        connectDragSource: connect.dragSource(),
+        connectDragPreview: connect.dragPreview(),
+        isDragging: monitor.isDragging()
+    };
+}
+exports.default = lodash_1.default.flow((0, react_dnd_1.DragSource)("visualization-block", blockSourceSpec, collectSource), (0, react_dnd_1.DropTarget)("visualization-block", blockTargetSpec, collectTarget))(DraggableBlockComponent);

package/lib/layouts/blocks/HorizontalBlockComponent.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import { LayoutBlock } from "./blockUtils";
+export interface HorizontalBlockComponentProps {
+    block: LayoutBlock;
+    collapseColumns?: boolean;
+    renderBlock: any;
+    /** Called with (sourceBlock, targetBlock, side) when block is dropped on it. side is top, left, bottom, right */
+    onBlockDrop?: any;
+    /** Called with (block) when block is removed */
+    onBlockRemove?: any;
+    onBlockUpdate?: any;
+}
+interface HorizontalBlockComponentState {
+    dragInitialX: any;
+    leftSize: any;
+    rightSize: any;
+    dragXOffset: any;
+    dragIndex: any;
+}
+export default class HorizontalBlockComponent extends React.Component<HorizontalBlockComponentProps, HorizontalBlockComponentState> {
+    blockRefs: {
+        [blockId: string]: HTMLElement | null;
+    };
+    constructor(props: any);
+    componentWillUnmount(): void;
+    handleMouseDown: (index: any, ev: any) => void;
+    handleMouseMove: (ev: any) => void;
+    handleMouseUp: (ev: any) => void;
+    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+}
+export {};

package/lib/layouts/blocks/HorizontalBlockComponent.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+const DraggableBlockComponent_1 = __importDefault(require("./DraggableBlockComponent"));
+class HorizontalBlockComponent extends react_1.default.Component {
+    blockRefs;
+    constructor(props) {
+        super(props);
+        this.state = {
+            dragIndex: null,
+            dragInitialX: null,
+            dragXOffset: null,
+            leftSize: null,
+            rightSize: null
+        };
+        this.blockRefs = {};
+    }
+    componentWillUnmount() {
+        // Remove listeners
+        document.removeEventListener("mousemove", this.handleMouseMove);
+        return document.removeEventListener("mouseup", this.handleMouseUp);
+    }
+    handleMouseDown = (index, ev) => {
+        // Prevent html5 drag
+        ev.preventDefault();
+        // Get sizes of two blocks
+        this.setState({
+            dragIndex: index,
+            leftSize: this.blockRefs[`block${index}`].offsetWidth,
+            rightSize: this.blockRefs[`block${index + 1}`].offsetWidth
+        });
+        document.addEventListener("mousemove", this.handleMouseMove);
+        return document.addEventListener("mouseup", this.handleMouseUp);
+    };
+    handleMouseMove = (ev) => {
+        if (!this.state.dragInitialX) {
+            this.setState({ dragInitialX: ev.clientX });
+            return;
+        }
+        let dragXOffset = ev.clientX - this.state.dragInitialX;
+        // Can't make left block too small
+        if (dragXOffset < -this.state.leftSize + 100) {
+            dragXOffset = -this.state.leftSize + 100;
+        }
+        // Can't make right block too small
+        if (dragXOffset > this.state.rightSize - 100) {
+            dragXOffset = this.state.rightSize - 100;
+        }
+        return this.setState({ dragXOffset });
+    };
+    handleMouseUp = (ev) => {
+        // Remove listeners
+        document.removeEventListener("mousemove", this.handleMouseMove);
+        document.removeEventListener("mouseup", this.handleMouseUp);
+        // Determine weights of two blocks
+        const weights = this.props.block.weights || [];
+        const newLeftSize = this.state.leftSize + this.state.dragXOffset;
+        const newRightSize = this.state.rightSize - this.state.dragXOffset;
+        // Get current weights
+        const leftWeight = weights[this.state.dragIndex] || 1;
+        const rightWeight = weights[this.state.dragIndex + 1] || 1;
+        weights[this.state.dragIndex] = ((leftWeight + rightWeight) * newLeftSize) / (newLeftSize + newRightSize);
+        weights[this.state.dragIndex + 1] = ((leftWeight + rightWeight) * newRightSize) / (newLeftSize + newRightSize);
+        const block = lodash_1.default.extend({}, this.props.block, { weights });
+        this.props.onBlockUpdate(block);
+        return this.setState({ dragIndex: null, dragInitialX: null, dragXOffset: null });
+    };
+    render() {
+        // Handle simple case of collapseColumns (no editing allowed)
+        let index, weight;
+        let asc, end;
+        let asc1, end1;
+        if (this.props.collapseColumns) {
+            return R("div", null, lodash_1.default.map(this.props.block.blocks, (block, index) => this.props.renderBlock(block, true)));
+        }
+        // Calculate widths (percentages)
+        let totalWeight = 0;
+        for (index = 0, end = this.props.block.blocks.length, asc = 0 <= end; asc ? index < end : index > end; asc ? index++ : index--) {
+            weight = (this.props.block.weights || [])[index] || 1;
+            totalWeight += (this.props.block.weights || [])[index] || 1;
+        }
+        const percentages = [];
+        for (index = 0, end1 = this.props.block.blocks.length, asc1 = 0 <= end1; asc1 ? index < end1 : index > end1; asc1 ? index++ : index--) {
+            weight = (this.props.block.weights || [])[index] || 1;
+            percentages[index] = (weight * 100) / totalWeight;
+        }
+        if (this.props.onBlockUpdate != null) {
+            let elem = R("table", {
+                style: { width: "100%", tableLayout: "fixed", position: "relative", paddingTop: 5 },
+                className: "mwater-visualization-horizontal-block"
+            }, // Add padding to allow dropping
+            R("tbody", null, R("tr", null, lodash_1.default.map(this.props.block.blocks, (block, index) => {
+                return [
+                    index > 0 && this.props.onBlockUpdate != null
+                        ? R("td", {
+                            style: { width: 5, position: "relative", left: this.state.dragXOffset },
+                            key: `splitter${index}`,
+                            className: `mwater-visualization-horizontal-block-splitter ${index - 1 === this.state.dragIndex ? "active" : ""}`,
+                            onMouseDown: this.handleMouseDown.bind(null, index - 1)
+                        })
+                        : undefined,
+                    R("td", {
+                        style: { width: `${percentages[index]}%`, verticalAlign: "top" },
+                        key: block.id,
+                        ref: (c) => {
+                            return (this.blockRefs[`block${index}`] = c);
+                        }
+                    }, this.props.renderBlock(block))
+                ];
+            }))));
+            // Allow dropping
+            elem = R(DraggableBlockComponent_1.default, {
+                block: this.props.block,
+                onBlockDrop: this.props.onBlockDrop
+            }, elem);
+            return elem;
+        }
+        else {
+            // Simplify in this case for printing
+            return R("div", { className: "mwater-visualization-horizontal-block" }, lodash_1.default.map(this.props.block.blocks, (block, index) => {
+                return [
+                    R("div", {
+                        style: { width: `${percentages[index]}%`, verticalAlign: "top", display: "inline-block" },
+                        key: block.id,
+                        ref: (c) => {
+                            return (this.blockRefs[`block${index}`] = c);
+                        },
+                        className: "mwater-visualization-horizontal-block-item"
+                    }, this.props.renderBlock(block))
+                ];
+            }));
+        }
+    }
+}
+exports.default = HorizontalBlockComponent;
+// handleAspectMouseDown: (ev) =>
+//   # Get height of overall block
+//   @setState(aspectDragY: ev.currentTarget.parentElement.offsetHeight, initialAspectDragY: ev.currentTarget.parentElement.offsetHeight)
+//   document.addEventListener("mousemove", @handleMouseMove)
+//   document.addEventListener("mouseup", @handleMouseUp)
+// handleMouseMove: (ev) =>
+//   if @state.initialClientY?
+//     aspectDragY = @state.initialAspectDragY + ev.clientY - @state.initialClientY
+//     if aspectDragY > 20
+//       @setState(aspectDragY: aspectDragY)
+//   else
+//     @setState(initialClientY: ev.clientY)
+// handleMouseUp: (ev) =>
+//   # Remove listeners
+//   document.removeEventListener("mousemove", @handleMouseMove)
+//   document.removeEventListener("mouseup", @handleMouseUp)
+//   # Fire new aspect ratio
+//   @props.onAspectRatioChange(@props.aspectRatio / (@state.aspectDragY / @state.initialAspectDragY))
+//   @setState(aspectDragY: null, initialAspectDragY: null, initialClientY: null)
+// renderAspectDrag: ->
+//   if @state.aspectDragY?
+//     lineStyle = {
+//       position: "absolute"
+//       borderTop: "solid 3px #38D"
+//       top: @state.aspectDragY
+//       left: 0
+//       right: 0
+//     }
+//     return R 'div', style: lineStyle, key: "aspectDrag"
+//   else
+//     return null
+// render: ->
+//   elem = R 'div', className: "mwater-visualization-decorated-block", style: @props.style,
+//     @props.children
+//     @renderAspectDrag()
+//     if not @props.isDragging and @props.connectMoveHandle?
+//       @props.connectMoveHandle(R 'div', key: "move", className: "mwater-visualization-decorated-block-move",
+//         R 'i', className: "fa fa-arrows")
+//     if not @props.isDragging and @props.onBlockRemove?
+//       R 'div', key: "remove", className: "mwater-visualization-decorated-block-remove", onClick: @props.onBlockRemove,
+//         R 'i', className: "fa fa-times"
+//     if not @props.isDragging and @props.onAspectRatioChange?
+//       # TODO sometimes drags (onDragStart) and so doesn't work. Disable dragging?
+//       R 'div', key: "aspect", className: "mwater-visualization-decorated-block-aspect", onMouseDown: @handleAspectMouseDown,
+//         R 'i', className: "fa fa-arrows-v"
+//     if not @props.isDragging and @props.connectResizeHandle?
+//       @props.connectResizeHandle(R 'div', key: "resize", className: "mwater-visualization-decorated-block-resize",
+//         R 'i', className: "fa fa-expand fa-rotate-90")
+//   if @props.connectDragPreview
+//     elem = @props.connectDragPreview(elem)
+//   return elem

package/lib/layouts/blocks/PaletteItemComponent.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export interface PaletteItemComponentProps {
+    /** Create the drag item */
+    createItem: any;
+    title?: any;
+    subtitle?: any;
+}
+export default class PaletteItemComponent extends React.Component<PaletteItemComponentProps> {
+    render(): React.CElement<{
+        createDragItem: any;
+    }, React.Component<{
+        createDragItem: any;
+    }, any, any>>;
+}

package/lib/layouts/blocks/PaletteItemComponent.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+const DragSourceComponent = require("../DragSourceComponent").default("visualization-block");
+// Item in a palette that can be dragged to add a widget or other item
+class PaletteItemComponent extends react_1.default.Component {
+    render() {
+        return R(DragSourceComponent, { createDragItem: this.props.createItem }, R("div", { className: "mwater-visualization-palette-item" }, R("div", { className: "title", key: "title" }, this.props.title), R("div", { className: "subtitle", key: "subtitle" }, this.props.subtitle)));
+    }
+}
+exports.default = PaletteItemComponent;

package/lib/layouts/blocks/README.md

@@ -0,0 +1,11 @@
+Layout that does blocks that are stacked vertically or horizontally alternately. That is, first is vertical stack, which can contain horizontal stack, etc.
+
+Contents:
+
+id: id of block
+type: "root"/"vertical"/"horizontal"/"widget"/"spacer"
+widgetType: if a widget
+aspectRatio: w/h if not autoHeight
+design: widget design
+weights: weights for proportioning horizontal blocks. Default is 1
+blocks: other blocks if not a widget

package/lib/layouts/blocks/blockUtils.d.ts

@@ -0,0 +1,22 @@
+/** Layout that does blocks that are stacked vertically or horizontally
+ * alternately. That is, first is vertical stack, which can contain horizontal
+ * stack, etc. */
+export interface LayoutBlock {
+    /** id of block */
+    id: string;
+    type: "root" | "vertical" | "horizontal" | "widget" | "spacer";
+    /** if a widget */
+    widgetType?: string;
+    /** w/h if not autoHeight */
+    aspectRatio?: number;
+    /** widget design */
+    design?: any;
+    /** weights for proportioning horizontal blocks. Default is 1 */
+    weights?: number[];
+    /** other blocks if not a widget */
+    blocks?: LayoutBlock[];
+}
+export declare function dropBlock(rootBlock: LayoutBlock, sourceBlock: LayoutBlock, targetBlock: LayoutBlock, side: "top" | "left" | "right" | "bottom"): LayoutBlock;
+export declare function updateBlock(rootBlock: LayoutBlock, block: LayoutBlock): LayoutBlock;
+export declare function removeBlock(rootBlock: LayoutBlock, block: LayoutBlock): LayoutBlock | null;
+export declare function cleanBlock(rootBlock: LayoutBlock): LayoutBlock;

package/lib/layouts/blocks/blockUtils.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanBlock = exports.removeBlock = exports.updateBlock = exports.dropBlock = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const uuid_1 = __importDefault(require("uuid"));
+// When block is dropped on it. side is top, left, bottom, right)
+// returns new root block
+function dropBlock(rootBlock, sourceBlock, targetBlock, side) {
+    // Handle root case, only dropping on bottom
+    if (targetBlock.type === "root" && rootBlock.id === targetBlock.id) {
+        const blocks = rootBlock.blocks.slice();
+        blocks.push(sourceBlock);
+        return lodash_1.default.extend({}, rootBlock, { blocks });
+    }
+    // If vertical
+    if (["vertical", "root"].includes(rootBlock.type)) {
+        let blocks = rootBlock.blocks;
+        // Find target block
+        const index = lodash_1.default.findIndex(blocks, { id: targetBlock.id });
+        if (index >= 0) {
+            blocks = blocks.slice();
+            // Add
+            switch (side) {
+                case "top":
+                    blocks.splice(index, 0, sourceBlock);
+                    break;
+                case "bottom":
+                    blocks.splice(index + 1, 0, sourceBlock);
+                    break;
+                case "left":
+                    blocks.splice(index, 1, { id: (0, uuid_1.default)(), type: "horizontal", blocks: [sourceBlock, targetBlock] });
+                    break;
+                case "right":
+                    blocks.splice(index, 1, { id: (0, uuid_1.default)(), type: "horizontal", blocks: [targetBlock, sourceBlock] });
+                    break;
+            }
+            return lodash_1.default.extend({}, rootBlock, { blocks });
+        }
+        else {
+            // Recurse
+            blocks = lodash_1.default.map(blocks, (block) => dropBlock(block, sourceBlock, targetBlock, side));
+            return lodash_1.default.extend({}, rootBlock, { blocks });
+        }
+    }
+    // If horizontal
+    if (rootBlock.type === "horizontal") {
+        let blocks = rootBlock.blocks;
+        // Find target block
+        const index = lodash_1.default.findIndex(blocks, { id: targetBlock.id });
+        if (index >= 0) {
+            blocks = blocks.slice();
+            // TODO splice into weights
+            // TODO weights as map?
+            // Add
+            switch (side) {
+                case "left":
+                    blocks.splice(index, 0, sourceBlock);
+                    break;
+                case "right":
+                    blocks.splice(index + 1, 0, sourceBlock);
+                    break;
+                case "top":
+                    blocks.splice(index, 1, { id: (0, uuid_1.default)(), type: "vertical", blocks: [sourceBlock, targetBlock] });
+                    break;
+                case "bottom":
+                    blocks.splice(index, 1, { id: (0, uuid_1.default)(), type: "vertical", blocks: [targetBlock, sourceBlock] });
+                    break;
+            }
+            return lodash_1.default.extend({}, rootBlock, { blocks });
+        }
+        else {
+            // Recurse
+            blocks = lodash_1.default.map(blocks, (block) => dropBlock(block, sourceBlock, targetBlock, side));
+            return lodash_1.default.extend({}, rootBlock, { blocks });
+        }
+    }
+    return rootBlock;
+}
+exports.dropBlock = dropBlock;
+// Updates a block
+// returns new root block
+function updateBlock(rootBlock, block) {
+    // If vertical or horizontal
+    if (["vertical", "horizontal", "root"].includes(rootBlock.type)) {
+        let { blocks } = rootBlock;
+        // Update block
+        blocks = lodash_1.default.map(blocks, function (b) {
+            if (b.id === block.id) {
+                return block;
+            }
+            else {
+                return b;
+            }
+        });
+        // Recurse
+        blocks = lodash_1.default.map(blocks, (b) => updateBlock(b, block));
+        return lodash_1.default.extend({}, rootBlock, { blocks });
+    }
+    return rootBlock;
+}
+exports.updateBlock = updateBlock;
+// When block is removed
+// returns new root block
+function removeBlock(rootBlock, block) {
+    // If vertical or horizontal
+    if (["vertical", "horizontal", "root"].includes(rootBlock.type)) {
+        let blocks = rootBlock.blocks;
+        // Remove blocks
+        blocks = lodash_1.default.filter(blocks, (b) => b.id !== block.id);
+        // TODO remove weight
+        // Recurse
+        blocks = lodash_1.default.compact(lodash_1.default.map(blocks, (b) => removeBlock(b, block)));
+        // If empty and not root, return null
+        if (blocks.length === 0 && rootBlock.type !== "root") {
+            return null;
+        }
+        return { ...rootBlock, blocks };
+    }
+    return rootBlock;
+}
+exports.removeBlock = removeBlock;
+// Clean blocks, simplifying as needed
+function cleanBlock(rootBlock) {
+    // If vertical or horizontal
+    if (["vertical", "horizontal", "root"].includes(rootBlock.type)) {
+        let blocks = rootBlock.blocks;
+        // Simplify
+        if (blocks.length === 1 && rootBlock.type !== "root") {
+            return blocks[0];
+        }
+        // Simplify nested blocks of same type (e.g. vertical inside root becomes a flat list)
+        blocks = lodash_1.default.flatten(lodash_1.default.map(blocks, function (b) {
+            if (b.type === "horizontal" && rootBlock.type === "horizontal") {
+                return b.blocks;
+            }
+            if (b.type === "vertical" && ["root", "vertical"].includes(rootBlock.type)) {
+                return b.blocks;
+            }
+            return b;
+        }));
+        // TODO # Truncate weights
+        // weights = null
+        // if rootBlock.type == "horizontal" and rootBlock.weights
+        //   if rootBlock.weights.length > blocks.length
+        //     weights = _.take(rootBlock.w)
+        // Recurse
+        blocks = lodash_1.default.map(blocks, (b) => cleanBlock(b));
+        return lodash_1.default.extend({}, rootBlock, { blocks });
+    }
+    return rootBlock;
+}
+exports.cleanBlock = cleanBlock;