Socket
Socket
Sign inDemoInstall

blueshell

Package Overview
Dependencies
5
Maintainers
2
Versions
241
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 1.4.0-graphviz.1 to 1.4.0-graphviz.2

dist/utils/archyTree.d.ts
dist/utils/archyTree.js
dist/utils/archyTree.js.map
dist/utils/dotTree.d.ts
dist/utils/dotTree.js
dist/utils/dotTree.js.map
lib/utils/archyTree.ts
lib/utils/dotTree.ts

4

dist/index.d.ts

@@ -11,3 +11,3 @@ import { Base } from './nodes/Base';

import * as decorators from './nodes/decorators';
import { toString, toConsole } from './utils/renderTree';
import { toString, toConsole, toDotString, toDotConsole } from './utils/renderTree';
export { Base as Action };

@@ -19,2 +19,4 @@ export { Base as Condition };

toConsole: typeof toConsole;
toDotString: typeof toDotString;
toDotConsole: typeof toDotConsole;
};

2

dist/index.js

@@ -28,3 +28,5 @@ "use strict";

toConsole: renderTree_1.toConsole,
toDotString: renderTree_1.toDotString,
toDotConsole: renderTree_1.toDotConsole,
};
//# sourceMappingURL=index.js.map

3

dist/utils/renderTree.d.ts

@@ -6,4 +6,5 @@ /**

import { BlueshellState } from '../nodes/BlueshellState';
export declare function generateDigraphString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): string;
export declare function toString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): string;
export declare function toConsole<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): void;
export declare function toDotString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): any;
export declare function toDotConsole<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): void;

109

dist/utils/renderTree.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const archy = require("archy");
const _ = require("lodash");
const Selector_1 = require("../nodes/Selector");
const LatchedSelector_1 = require("../nodes/LatchedSelector");
const LatchedSequence_1 = require("../nodes/LatchedSequence");
const Sequence_1 = require("../nodes/Sequence");
const IfElse_1 = require("../nodes/IfElse");
const decorators_1 = require("../nodes/decorators");
function buildArchyTree(node, state) {
let nodeLabel = node.name;
if (nodeLabel !== node.constructor.name) {
nodeLabel += ' (' + node.constructor.name + ')';
}
if (state) {
let eventCounter = node.getTreeEventCounter(state);
let lastEventSeen = node.getLastEventSeen(state);
let lastResult = node.getLastResult(state);
if (lastEventSeen === eventCounter && lastResult) {
nodeLabel += ' => ' + lastResult;
}
}
const archyTree = {
label: nodeLabel,
nodes: new Array(),
};
if (node.children) {
for (let child of node.children) {
archyTree.nodes.push(buildArchyTree(child, state));
}
}
return archyTree;
}
function iterativePreOrderTraversal(root, visit, state) {
if (!root) {
return;
}
let nodesToVisit = [];
let resultingString = '';
nodesToVisit.push(root);
while (!_.isEmpty(nodesToVisit)) {
let currentNode = nodesToVisit.pop();
resultingString += visit(currentNode, state);
if (currentNode.children) {
for (let child of [...currentNode.children].reverse()) {
nodesToVisit.push(child);
}
}
}
return resultingString;
}
function nodeInDotLanguage(node, state) {
let shape;
if (node instanceof LatchedSelector_1.LatchedSelector) {
shape = 'Mdiamond';
}
else if (node instanceof Selector_1.Selector) {
shape = 'diamond';
}
else if (node instanceof LatchedSequence_1.LatchedSequence) {
shape = 'doubleoctagon';
}
else if (node instanceof Sequence_1.Sequence) {
shape = 'octagon';
}
else if (node instanceof IfElse_1.IfElse) {
shape = 'invtriangle';
}
else if (node instanceof decorators_1.Not) {
shape = 'circle';
}
else if (node instanceof decorators_1.RepeatOnResult) {
shape = 'house';
}
else if (node instanceof decorators_1.RepeatWhen) {
shape = 'invhouse';
}
else if (node instanceof decorators_1.ResultSwap) {
shape = 'egg';
}
else {
shape = 'rectangle';
}
let nodeLabel = node.name;
if (nodeLabel !== node.constructor.name) {
nodeLabel += ' (' + node.constructor.name + ')';
}
return `\t${nodeLabel} [shape=${shape}];\n`;
}
function generateDigraphString(tree, state) {
let digraphString = `digraph G {
${iterativePreOrderTraversal(tree, nodeInDotLanguage, state)}
}`;
return digraphString;
}
exports.generateDigraphString = generateDigraphString;
const archyTree_1 = require("./archyTree");
const dotTree_1 = require("./dotTree");
function toString(tree, state) {
let a = buildArchyTree(tree, state);
let renderedTree = archy(a);
return renderedTree;
return archyTree_1.serializeArchyTree(tree, state);
}

@@ -108,2 +13,10 @@ exports.toString = toString;

exports.toConsole = toConsole;
function toDotString(tree, state) {
return dotTree_1.serializeDotTree(tree, state);
}
exports.toDotString = toDotString;
function toDotConsole(tree, state) {
console.log(toDotString(tree, state)); // eslint-disable-line no-console
}
exports.toDotConsole = toDotConsole;
//# sourceMappingURL=renderTree.js.map

2

dist/utils/resultCodes.js

@@ -11,4 +11,4 @@ "use strict";

RUNNING: 'RUNNING',
ERROR: 'ERROR'
ERROR: 'ERROR',
};
//# sourceMappingURL=resultCodes.js.map

8

lib/index.ts

@@ -13,3 +13,3 @@ import {Base} from './nodes/Base';

import {toString, toConsole} from './utils/renderTree';
import {toString, toConsole, toDotString, toDotConsole} from './utils/renderTree';

@@ -22,4 +22,6 @@ export {Base as Action};

export const renderTree = {
toString,
toConsole,
toString,
toConsole,
toDotString,
toDotConsole,
};

120

lib/utils/renderTree.ts

@@ -6,119 +6,19 @@ /**

import {BlueshellState} from '../nodes/BlueshellState';
import {serializeArchyTree} from './archyTree';
import {serializeDotTree} from './dotTree';
import * as archy from 'archy';
import {Data} from 'archy';
import * as _ from 'lodash';
import { Selector } from '../nodes/Selector';
import { LatchedSelector } from '../nodes/LatchedSelector';
import { LatchedSequence } from '../nodes/LatchedSequence';
import {Sequence} from '../nodes/Sequence';
import { IfElse } from '../nodes/IfElse';
import {Not, RepeatOnResult, RepeatWhen, ResultSwap} from '../nodes/decorators';
function buildArchyTree<S extends BlueshellState, E>(node: Base<S, E>, state?: S): Data {
let nodeLabel = node.name;
if (nodeLabel !== node.constructor.name) {
nodeLabel += ' (' + node.constructor.name + ')';
}
if (state) {
let eventCounter = node.getTreeEventCounter(state);
let lastEventSeen = node.getLastEventSeen(state);
let lastResult = node.getLastResult(state);
if (lastEventSeen === eventCounter && lastResult) {
nodeLabel += ' => ' + lastResult;
}
}
const archyTree = {
label: nodeLabel,
nodes: new Array<Data | string>(),
};
if ((<any>node).children) {
for (let child of (<any>node).children) {
archyTree.nodes.push(buildArchyTree(<Base<S,E>>child, state));
}
}
return archyTree;
export function toString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): string {
return serializeArchyTree(tree, state);
}
function iterativePreOrderTraversal<S extends BlueshellState, E>(root: Base<S, E>, visit: (node: Base<S, E>, state?: S) => any, state?: S): any {
if(!root) {
return;
}
let nodesToVisit: Base<S, E>[] = [];
let resultingString = '';
nodesToVisit.push(root);
while(!_.isEmpty(nodesToVisit)) {
let currentNode = nodesToVisit.pop();
resultingString += visit(currentNode!, state);
if((<any>currentNode).children) {
for (let child of [...(<any>currentNode).children].reverse()) {
nodesToVisit.push(child);
}
}
}
return resultingString;
export function toConsole<S extends BlueshellState, E>(tree: Base<S, E>, state?: S) {
console.log(toString(tree, state)); // eslint-disable-line no-console
}
function nodeInDotLanguage<S extends BlueshellState, E>(node: Base<S, E>, state?: S): string {
let shape;
if(node instanceof LatchedSelector) {
shape = 'Mdiamond';
} else if (node instanceof Selector) {
shape = 'diamond';
} else if (node instanceof LatchedSequence) {
shape = 'doubleoctagon';
} else if (node instanceof Sequence) {
shape = 'octagon';
} else if (node instanceof IfElse) {
shape = 'invtriangle';
} else if (node instanceof Not) {
shape = 'circle';
} else if (node instanceof RepeatOnResult) {
shape = 'house';
} else if (node instanceof RepeatWhen) {
shape = 'invhouse';
} else if (node instanceof ResultSwap) {
shape = 'egg';
} else {
shape = 'rectangle';
}
let nodeLabel = node.name;
if (nodeLabel !== node.constructor.name) {
nodeLabel += ' (' + node.constructor.name + ')';
}
return `\t${nodeLabel} [shape=${shape}];\n`;
export function toDotString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S) {
return serializeDotTree(tree, state);
}
export function generateDigraphString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): string {
let digraphString = `digraph G {
${iterativePreOrderTraversal(tree, nodeInDotLanguage, state)}
}`;
return digraphString;
export function toDotConsole<S extends BlueshellState, E>(tree: Base<S, E>, state?: S) {
console.log(toDotString(tree, state)); // eslint-disable-line no-console
}
export function toString<S extends BlueshellState, E>(tree: Base<S, E>, state?: S): string {
let a = buildArchyTree(tree, state);
let renderedTree = archy(a);
return renderedTree;
}
export function toConsole<S extends BlueshellState, E>(tree: Base<S, E>, state?: S) {
console.log(toString(tree, state)); // eslint-disable-line no-console
}

2

lib/utils/resultCodes.ts

@@ -9,3 +9,3 @@ /**

RUNNING: 'RUNNING',
ERROR: 'ERROR'
ERROR: 'ERROR',
};

2

package.json

@@ -101,3 +101,3 @@ {

"types": "dist/index.d.ts",
"version": "1.4.0-graphviz.1"
"version": "1.4.0-graphviz.2"
}
dist/index.js.map

Sorry, the diff of this file is not supported yet

dist/utils/renderTree.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc