@makano/rew 1.1.8 → 1.1.9

package/lib/rew/pkgs/modules/data/bintree.js

@@ -1,66 +1,66 @@
 class TreeNode {
-  constructor(value) {
-    this.value = value;
-    this.left = null;
-    this.right = null;
-  }
+	constructor(value) {
+		this.value = value;
+		this.left = null;
+		this.right = null;
+	}
 }
 
 class BinaryTree {
-  constructor() {
-    this.root = null;
-  }
+	constructor() {
+		this.root = null;
+	}
 
-  insert(value) {
-    const newNode = new TreeNode(value);
-    if (!this.root) {
-      this.root = newNode;
-      return;
-    }
+	insert(value) {
+		const newNode = new TreeNode(value);
+		if (!this.root) {
+			this.root = newNode;
+			return;
+		}
 
-    const insertNode = (node) => {
-      if (value < node.value) {
-        if (!node.left) {
-          node.left = newNode;
-        } else {
-          insertNode(node.left);
-        }
-      } else {
-        if (!node.right) {
-          node.right = newNode;
-        } else {
-          insertNode(node.right);
-        }
-      }
-    };
+		const insertNode = (node) => {
+			if (value < node.value) {
+				if (!node.left) {
+					node.left = newNode;
+				} else {
+					insertNode(node.left);
+				}
+			} else {
+				if (!node.right) {
+					node.right = newNode;
+				} else {
+					insertNode(node.right);
+				}
+			}
+		};
 
-    insertNode(this.root);
-  }
+		insertNode(this.root);
+	}
 
-  find(value) {
-    const findNode = (node) => {
-      if (!node) return null;
-      if (node.value === value) return node;
-      if (value < node.value) return findNode(node.left);
-      return findNode(node.right);
-    };
+	find(value) {
+		const findNode = (node) => {
+			if (!node) return null;
+			if (node.value === value) return node;
+			if (value < node.value) return findNode(node.left);
+			return findNode(node.right);
+		};
 
-    return findNode(this.root);
-  }
+		return findNode(this.root);
+	}
 
-  toArray() {
-    const elements = [];
-    const traverse = (node) => {
-      if (!node) return;
-      traverse(node.left);
-      elements.push(node.value);
-      traverse(node.right);
-    };
-    traverse(this.root);
-    return elements;
-  }
+	toArray() {
+		const elements = [];
+		const traverse = (node) => {
+			if (!node) return;
+			traverse(node.left);
+			elements.push(node.value);
+			traverse(node.right);
+		};
+		traverse(this.root);
+		return elements;
+	}
 }
 
 BinaryTree.Node = TreeNode;
 
-module.exports = { BinaryTree };
+module.exports = { BinaryTree };

package/lib/rew/pkgs/modules/data/doublylinked.js

@@ -1,100 +1,100 @@
 class DoublyNode {
-  constructor(value) {
-    this.value = value;
-    this.next = null;
-    this.prev = null;
-  }
+	constructor(value) {
+		this.value = value;
+		this.next = null;
+		this.prev = null;
+	}
 }
 
 class DoublyLinkedList {
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
+	constructor() {
+		this.head = null;
+		this.tail = null;
+		this.length = 0;
+	}
 
-  append(value) {
-    const newNode = new DoublyNode(value);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      this.tail.next = newNode;
-      newNode.prev = this.tail;
-      this.tail = newNode;
-    }
-    this.length++;
-  }
+	append(value) {
+		const newNode = new DoublyNode(value);
+		if (!this.head) {
+			this.head = newNode;
+			this.tail = newNode;
+		} else {
+			this.tail.next = newNode;
+			newNode.prev = this.tail;
+			this.tail = newNode;
+		}
+		this.length++;
+	}
 
-  prepend(value) {
-    const newNode = new DoublyNode(value);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      newNode.next = this.head;
-      this.head.prev = newNode;
-      this.head = newNode;
-    }
-    this.length++;
-  }
+	prepend(value) {
+		const newNode = new DoublyNode(value);
+		if (!this.head) {
+			this.head = newNode;
+			this.tail = newNode;
+		} else {
+			newNode.next = this.head;
+			this.head.prev = newNode;
+			this.head = newNode;
+		}
+		this.length++;
+	}
 
-  find(value) {
-    let current = this.head;
-    while (current) {
-      if (current.value === value) {
-        return current;
-      }
-      current = current.next;
-    }
-    return null;
-  }
+	find(value) {
+		let current = this.head;
+		while (current) {
+			if (current.value === value) {
+				return current;
+			}
+			current = current.next;
+		}
+		return null;
+	}
 
-  delete(value) {
-    if (!this.head) {
-      return null;
-    }
+	delete(value) {
+		if (!this.head) {
+			return null;
+		}
 
-    if (this.head.value === value) {
-      this.head = this.head.next;
-      if (this.head) {
-        this.head.prev = null;
-      } else {
-        this.tail = null;
-      }
-      this.length--;
-      return;
-    }
+		if (this.head.value === value) {
+			this.head = this.head.next;
+			if (this.head) {
+				this.head.prev = null;
+			} else {
+				this.tail = null;
+			}
+			this.length--;
+			return;
+		}
 
-    let current = this.head;
-    while (current) {
-      if (current.value === value) {
-        if (current.next) {
-          current.next.prev = current.prev;
-        } else {
-          this.tail = current.prev;
-        }
-        if (current.prev) {
-          current.prev.next = current.next;
-        }
-        this.length--;
-        return;
-      }
-      current = current.next;
-    }
-  }
+		let current = this.head;
+		while (current) {
+			if (current.value === value) {
+				if (current.next) {
+					current.next.prev = current.prev;
+				} else {
+					this.tail = current.prev;
+				}
+				if (current.prev) {
+					current.prev.next = current.next;
+				}
+				this.length--;
+				return;
+			}
+			current = current.next;
+		}
+	}
 
-  toArray() {
-    const elements = [];
-    let current = this.head;
-    while (current) {
-      elements.push(current.value);
-      current = current.next;
-    }
-    return elements;
-  }
+	toArray() {
+		const elements = [];
+		let current = this.head;
+		while (current) {
+			elements.push(current.value);
+			current = current.next;
+		}
+		return elements;
+	}
 }
 
 DoublyLinkedList.Node = DoublyNode;
 
-module.exports = { DoublyLinkedList };
+module.exports = { DoublyLinkedList };

package/lib/rew/pkgs/modules/data/linkedList.js

@@ -1,88 +1,88 @@
 class Node {
-  constructor(value) {
-    this.value = value;
-    this.next = null;
-  }
+	constructor(value) {
+		this.value = value;
+		this.next = null;
+	}
 }
 
 class LinkedList {
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
+	constructor() {
+		this.head = null;
+		this.tail = null;
+		this.length = 0;
+	}
 
-  append(value) {
-    const newNode = new Node(value);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      this.tail.next = newNode;
-      this.tail = newNode;
-    }
-    this.length++;
-  }
+	append(value) {
+		const newNode = new Node(value);
+		if (!this.head) {
+			this.head = newNode;
+			this.tail = newNode;
+		} else {
+			this.tail.next = newNode;
+			this.tail = newNode;
+		}
+		this.length++;
+	}
 
-  prepend(value) {
-    const newNode = new Node(value);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      newNode.next = this.head;
-      this.head = newNode;
-    }
-    this.length++;
-  }
+	prepend(value) {
+		const newNode = new Node(value);
+		if (!this.head) {
+			this.head = newNode;
+			this.tail = newNode;
+		} else {
+			newNode.next = this.head;
+			this.head = newNode;
+		}
+		this.length++;
+	}
 
-  find(value) {
-    let current = this.head;
-    while (current) {
-      if (current.value === value) {
-        return current;
-      }
-      current = current.next;
-    }
-    return null;
-  }
+	find(value) {
+		let current = this.head;
+		while (current) {
+			if (current.value === value) {
+				return current;
+			}
+			current = current.next;
+		}
+		return null;
+	}
 
-  delete(value) {
-    if (!this.head) {
-      return null;
-    }
+	delete(value) {
+		if (!this.head) {
+			return null;
+		}
 
-    if (this.head.value === value) {
-      this.head = this.head.next;
-      this.length--;
-      return;
-    }
+		if (this.head.value === value) {
+			this.head = this.head.next;
+			this.length--;
+			return;
+		}
 
-    let current = this.head;
-    while (current.next) {
-      if (current.next.value === value) {
-        current.next = current.next.next;
-        if (current.next === null) {
-          this.tail = current;
-        }
-        this.length--;
-        return;
-      }
-      current = current.next;
-    }
-  }
+		let current = this.head;
+		while (current.next) {
+			if (current.next.value === value) {
+				current.next = current.next.next;
+				if (current.next === null) {
+					this.tail = current;
+				}
+				this.length--;
+				return;
+			}
+			current = current.next;
+		}
+	}
 
-  toArray() {
-    const elements = [];
-    let current = this.head;
-    while (current) {
-      elements.push(current.value);
-      current = current.next;
-    }
-    return elements;
-  }
+	toArray() {
+		const elements = [];
+		let current = this.head;
+		while (current) {
+			elements.push(current.value);
+			current = current.next;
+		}
+		return elements;
+	}
 }
 
 LinkedList.Node = Node;
 
-module.exports = { LinkedList };
+module.exports = { LinkedList };

package/lib/rew/pkgs/modules/data/queue.js

@@ -1,28 +1,27 @@
 class Queue {
-  constructor() {
-    this.items = [];
-  }
+	constructor() {
+		this.items = [];
+	}
 
-  enqueue(item) {
-    this.items.push(item);
-  }
+	enqueue(item) {
+		this.items.push(item);
+	}
 
-  dequeue() {
-    return this.items.shift();
-  }
+	dequeue() {
+		return this.items.shift();
+	}
 
-  isEmpty() {
-    return this.items.length === 0;
-  }
+	isEmpty() {
+		return this.items.length === 0;
+	}
 
-  peek() {
-    return this.items[0];
-  }
+	peek() {
+		return this.items[0];
+	}
 
-  toArray() {
-    return this.items.slice();
-  }
+	toArray() {
+		return this.items.slice();
+	}
 }
 
-
-module.exports = { Queue };
+module.exports = { Queue };

package/lib/rew/pkgs/modules/data/stack.js

@@ -1,27 +1,27 @@
 class Stack {
-  constructor() {
-    this.items = [];
-  }
+	constructor() {
+		this.items = [];
+	}
 
-  push(item) {
-    this.items.push(item);
-  }
+	push(item) {
+		this.items.push(item);
+	}
 
-  pop() {
-    return this.items.pop();
-  }
+	pop() {
+		return this.items.pop();
+	}
 
-  isEmpty() {
-    return this.items.length === 0;
-  }
+	isEmpty() {
+		return this.items.length === 0;
+	}
 
-  peek() {
-    return this.items[this.items.length - 1];
-  }
+	peek() {
+		return this.items[this.items.length - 1];
+	}
 
-  toArray() {
-    return this.items.slice();
-  }
+	toArray() {
+		return this.items.slice();
+	}
 }
 
-module.exports = { Stack };
+module.exports = { Stack };

package/lib/rew/pkgs/modules/threads/worker.js

@@ -4,34 +4,44 @@ const { exec } = require('../../../modules/runtime');
 const target = {};
 target.events = [];
 target.on = (e, cb) => {
-  target.events.push({ e, cb });
-}
+	target.events.push({ e, cb });
+};
 target.off = (e) => {
-  target.events = target.events.filter(i => i.e !== e);
-}
+	target.events = target.events.filter((i) => i.e !== e);
+};
 target.emit = (e, data) => {
-  target.events.filter(i => i.e == e).forEach(i => i.cb(data));
-}
+	target.events.filter((i) => i.e == e).forEach((i) => i.cb(data));
+};
 
 parentPort.on('message', (data) => {
-  if (data.type === 'event') {
-    target.emit(data.event, data.data);
-  } else if (data.type === 'start') {
-    (async () => {
-      try {
-        exec(`(${workerData.cb}).call({ process }, context)`, { print: (...a) => console.log(...a), process: {
-          on: (e, cb) => { target.on(e, cb) },
-          off: (e) => { target.off(e) },
-          emit: (e, data) => { parentPort.postMessage({ type: 'event', event: e, data }) },
-          exit: (code) => process.exit(code),
-          finish: (data) => {
-            parentPort.postMessage({ type: 'result', result: data });
-            process.exit(0)
-          }
-        }, context: workerData.context })
-      } catch (e) {
-        parentPort.postMessage({ type: 'error', error: e.message });
-      }
-    })();
-  }
+	if (data.type === 'event') {
+		target.emit(data.event, data.data);
+	} else if (data.type === 'start') {
+		(async () => {
+			try {
+				exec(`(${workerData.cb}).call({ process }, context)`, {
+					print: (...a) => console.log(...a),
+					process: {
+						on: (e, cb) => {
+							target.on(e, cb);
+						},
+						off: (e) => {
+							target.off(e);
+						},
+						emit: (e, data) => {
+							parentPort.postMessage({ type: 'event', event: e, data });
+						},
+						exit: (code) => process.exit(code),
+						finish: (data) => {
+							parentPort.postMessage({ type: 'result', result: data });
+							process.exit(0);
+						},
+					},
+					context: workerData.context,
+				});
+			} catch (e) {
+				parentPort.postMessage({ type: 'error', error: e.message });
+			}
+		})();
+	}
 });