whet 0.0.5 → 0.0.6

package/bin/StringBuf.d.ts

@@ -0,0 +1,13 @@
+
+/**
+A String buffer is an efficient way to build a big string by appending small
+elements together.
+
+Unlike String, an instance of StringBuf is not immutable in the sense that
+it can be passed as argument to functions which modify it by appending more
+values.
+*/
+export declare class StringBuf {
+	constructor()
+	protected b: string
+}

package/bin/StringBuf.js

@@ -0,0 +1,25 @@
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+/**
+A String buffer is an efficient way to build a big string by appending small
+elements together.
+
+Unlike String, an instance of StringBuf is not immutable in the sense that
+it can be passed as argument to functions which modify it by appending more
+values.
+*/
+export const StringBuf = Register.global("$hxClasses")["StringBuf"] = 
+class StringBuf extends Register.inherits() {
+	new() {
+		this.b = "";
+	}
+	static get __name__() {
+		return "StringBuf"
+	}
+	get __class__() {
+		return StringBuf
+	}
+}
+

package/bin/haxe/CallStack.d.ts

@@ -0,0 +1,41 @@
+import {StringBuf} from "../StringBuf"
+
+/**
+Elements return by `CallStack` methods.
+*/
+export declare namespace StackItem {
+	export type Module = {_hx_index: 1, m: string, __enum__: "haxe.StackItem"}
+	export const Module: (m: string) => StackItem
+	export type Method = {_hx_index: 3, classname: null | string, method: string, __enum__: "haxe.StackItem"}
+	export const Method: (classname: null | string, method: string) => StackItem
+	export type LocalFunction = {_hx_index: 4, v: null | number, __enum__: "haxe.StackItem"}
+	export const LocalFunction: (v: null | number) => StackItem
+	export type FilePos = {_hx_index: 2, s: null | StackItem, file: string, line: number, column: null | number, __enum__: "haxe.StackItem"}
+	export const FilePos: (s: null | StackItem, file: string, line: number, column: null | number) => StackItem
+	export type CFunction = {_hx_index: 0, __enum__: "haxe.StackItem"}
+	export const CFunction: CFunction
+}
+
+/**
+Elements return by `CallStack` methods.
+*/
+export declare type StackItem = 
+	| StackItem.Module
+	| StackItem.Method
+	| StackItem.LocalFunction
+	| StackItem.FilePos
+	| StackItem.CFunction
+
+export declare class CallStack {
+	
+	/**
+	Return the call stack elements, or an empty array if not available.
+	*/
+	static callStack(): StackItem[]
+	
+	/**
+	Returns a representation of the stack as a printable string.
+	*/
+	static toString(stack: StackItem[]): string
+	protected static itemToString(b: StringBuf, s: StackItem): void
+}

package/bin/haxe/CallStack.js

@@ -0,0 +1,96 @@
+import {NativeStackTrace} from "./NativeStackTrace.js"
+import {Register} from "../genes/Register.js"
+import {StringBuf} from "../StringBuf.js"
+import {Std} from "../Std.js"
+
+const $global = Register.$global
+
+/**
+Elements return by `CallStack` methods.
+*/
+export const StackItem = 
+Register.global("$hxEnums")["haxe.StackItem"] = 
+{
+	__ename__: "haxe.StackItem",
+	
+	CFunction: {_hx_name: "CFunction", _hx_index: 0, __enum__: "haxe.StackItem"},
+	Module: Object.assign((m) => ({_hx_index: 1, __enum__: "haxe.StackItem", "m": m}), {_hx_name: "Module", __params__: ["m"]}),
+	FilePos: Object.assign((s, file, line, column) => ({_hx_index: 2, __enum__: "haxe.StackItem", "s": s, "file": file, "line": line, "column": column}), {_hx_name: "FilePos", __params__: ["s", "file", "line", "column"]}),
+	Method: Object.assign((classname, method) => ({_hx_index: 3, __enum__: "haxe.StackItem", "classname": classname, "method": method}), {_hx_name: "Method", __params__: ["classname", "method"]}),
+	LocalFunction: Object.assign((v) => ({_hx_index: 4, __enum__: "haxe.StackItem", "v": v}), {_hx_name: "LocalFunction", __params__: ["v"]})
+}
+StackItem.__constructs__ = [StackItem.CFunction, StackItem.Module, StackItem.FilePos, StackItem.Method, StackItem.LocalFunction]
+StackItem.__empty_constructs__ = [StackItem.CFunction]
+
+export const CallStack = Register.global("$hxClasses")["haxe._CallStack.CallStack"] = 
+class CallStack {
+	
+	/**
+	Return the call stack elements, or an empty array if not available.
+	*/
+	static callStack() {
+		return NativeStackTrace.toHaxe(NativeStackTrace.callStack());
+	}
+	
+	/**
+	Returns a representation of the stack as a printable string.
+	*/
+	static toString(stack) {
+		var b = new StringBuf();
+		var _g = 0;
+		var _g1 = stack;
+		while (_g < _g1.length) {
+			var s = _g1[_g++];
+			b.b += "\nCalled from ";
+			CallStack.itemToString(b, s);
+		};
+		return b.b;
+	}
+	static itemToString(b, s) {
+		switch (s._hx_index) {
+			case 0:
+				b.b += "a C function";
+				break
+			case 1:
+				var _g = s.m;
+				b.b = (b.b += "module ") + ((_g == null) ? "null" : "" + _g);
+				break
+			case 2:
+				var _g = s.s;
+				var _g1 = s.file;
+				var _g2 = s.line;
+				var _g3 = s.column;
+				if (_g != null) {
+					CallStack.itemToString(b, _g);
+					b.b += " (";
+				};
+				b.b = (b.b += (_g1 == null) ? "null" : "" + _g1) + " line ";
+				b.b += (_g2 == null) ? "null" : "" + _g2;
+				if (_g3 != null) {
+					b.b = (b.b += " column ") + ((_g3 == null) ? "null" : "" + _g3);
+				};
+				if (_g != null) {
+					b.b += ")";
+				};
+				break
+			case 3:
+				var _g = s.classname;
+				var _g1 = s.method;
+				b.b = (b.b += Std.string((_g == null) ? "<unknown>" : _g)) + ".";
+				b.b += (_g1 == null) ? "null" : "" + _g1;
+				break
+			case 4:
+				var _g = s.v;
+				b.b = (b.b += "local function #") + ((_g == null) ? "null" : "" + _g);
+				break
+			
+		};
+	}
+	static get __name__() {
+		return "haxe._CallStack.CallStack_Impl_"
+	}
+	get __class__() {
+		return CallStack
+	}
+}
+

package/bin/haxe/NativeStackTrace.js

@@ -0,0 +1,147 @@
+import {StackItem} from "./CallStack.js"
+import {Register} from "../genes/Register.js"
+import {StringTools} from "../StringTools.js"
+import {Std} from "../Std.js"
+
+const $global = Register.$global
+
+/**
+Do not use manually.
+*/
+export const NativeStackTrace = Register.global("$hxClasses")["haxe.NativeStackTrace"] = 
+class NativeStackTrace {
+	static callStack() {
+		var e = new Error("");
+		var stack = NativeStackTrace.tryHaxeStack(e);
+		if (typeof(stack) == "undefined") {
+			try {
+				throw e;
+			}catch (_g) {
+			};
+			stack = e.stack;
+		};
+		return NativeStackTrace.normalize(stack, 2);
+	}
+	static toHaxe(s, skip) {
+		if (skip == null) {
+			skip = 0;
+		};
+		if (s == null) {
+			return [];
+		} else if (typeof(s) == "string") {
+			var stack = s.split("\n");
+			if (stack[0] == "Error") {
+				stack.shift();
+			};
+			var m = [];
+			var _g = 0;
+			var _g1 = stack.length;
+			while (_g < _g1) {
+				var i = _g++;
+				if (skip > i) {
+					continue;
+				};
+				var line = stack[i];
+				var matched = line.match(/^    at ([A-Za-z0-9_. ]+) \(([^)]+):([0-9]+):([0-9]+)\)$/);
+				if (matched != null) {
+					var path = matched[1].split(".");
+					if (path[0] == "$hxClasses") {
+						path.shift();
+					};
+					var meth = path.pop();
+					var file = matched[2];
+					var line1 = Std.parseInt(matched[3]);
+					var column = Std.parseInt(matched[4]);
+					m.push(StackItem.FilePos((meth == "Anonymous function") ? StackItem.LocalFunction() : (meth == "Global code") ? null : StackItem.Method(path.join("."), meth), file, line1, column));
+				} else {
+					m.push(StackItem.Module(StringTools.trim(line)));
+				};
+			};
+			return m;
+		} else if (skip > 0 && Array.isArray(s)) {
+			return s.slice(skip);
+		} else {
+			return s;
+		};
+	}
+	static tryHaxeStack(e) {
+		if (e == null) {
+			return [];
+		};
+		var oldValue = Error.prepareStackTrace;
+		Error.prepareStackTrace = NativeStackTrace.prepareHxStackTrace;
+		Error.prepareStackTrace = oldValue;
+		return e.stack;
+	}
+	static prepareHxStackTrace(e, callsites) {
+		var stack = [];
+		var _g = 0;
+		while (_g < callsites.length) {
+			var site = callsites[_g];
+			++_g;
+			if (NativeStackTrace.wrapCallSite != null) {
+				site = NativeStackTrace.wrapCallSite(site);
+			};
+			var method = null;
+			var fullName = site.getFunctionName();
+			if (fullName != null) {
+				var idx = fullName.lastIndexOf(".");
+				if (idx >= 0) {
+					method = StackItem.Method(fullName.substring(0, idx), fullName.substring(idx + 1));
+				} else {
+					method = StackItem.Method(null, fullName);
+				};
+			};
+			var fileName = site.getFileName();
+			var fileAddr = (fileName == null) ? -1 : fileName.indexOf("file:");
+			if (NativeStackTrace.wrapCallSite != null && fileAddr > 0) {
+				fileName = fileName.substring(fileAddr + 6);
+			};
+			stack.push(StackItem.FilePos(method, fileName, site.getLineNumber(), site.getColumnNumber()));
+		};
+		return stack;
+	}
+	static normalize(stack, skipItems) {
+		if (skipItems == null) {
+			skipItems = 0;
+		};
+		if (Array.isArray(stack) && skipItems > 0) {
+			return stack.slice(skipItems);
+		} else if (typeof(stack) == "string") {
+			switch (stack.substring(0, 6)) {
+				case "Error\n":case "Error:":
+					++skipItems;
+					break
+				default:
+				
+			};
+			return NativeStackTrace.skipLines(stack, skipItems);
+		} else {
+			return stack;
+		};
+	}
+	static skipLines(stack, skip, pos) {
+		if (pos == null) {
+			pos = 0;
+		};
+		while (true) if (skip > 0) {
+			pos = stack.indexOf("\n", pos);
+			if (pos < 0) {
+				return "";
+			} else {
+				skip = --skip;
+				pos += 1;
+				continue;
+			};
+		} else {
+			return stack.substring(pos);
+		};
+	}
+	static get __name__() {
+		return "haxe.NativeStackTrace"
+	}
+	get __class__() {
+		return NativeStackTrace
+	}
+}
+

package/bin/whet/Log.js

@@ -54,6 +54,9 @@ class Log {
 		};
 	}
 	static replacer(key, val) {
+		if (((val) instanceof Error)) {
+			return val.stack;
+		};
 		if (val != null && typeof(val.toString) == "function" && val.toString != Object.prototype.toString) {
 			return val.toString();
 		};

package/bin/whet/Project.d.ts

@@ -9,6 +9,7 @@ export declare class Project {
 	description: string
 	rootDir: string
 	cache: CacheManager
+	stones: AnyStone[]
 	onInit: (config: any) => Promise<any>
 	protected options: Option[]
 	addCommand(cmd: Command, stone?: null | AnyStone): void

package/bin/whet/Project.js

@@ -1,17 +1,17 @@
 import {CacheManager} from "./cache/CacheManager.js"
 import {Whet_Fields_} from "./Whet.js"
+import {SourceId_Fields_} from "./SourceId.js"
 import {Log} from "./Log.js"
 import * as Path from "path"
-import {Path as Path__1} from "../haxe/io/Path.js"
 import {Register} from "../genes/Register.js"
 import {StringTools} from "../StringTools.js"
-import {HxOverrides} from "../HxOverrides.js"
 
 const $global = Register.$global
 
 export const Project = Register.global("$hxClasses")["whet.Project"] = 
 class Project extends Register.inherits() {
 	new(config) {
+		this.stones = [];
 		this.cache = null;
 		var this1 = ["Instantiating new Project."];
 		Log.log(20, ...this1);
@@ -37,14 +37,18 @@ class Project extends Register.inherits() {
 			file = decodeURI(file);
 			file = StringTools.replace(file, "file:///", "");
 			var s = Path.relative(process.cwd(), file);
-			var norm = "/" + Path__1.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
-			var s1 = Path__1.addTrailingSlash(Path__1.directory((s.lastIndexOf("/") == s.length - 1) ? Path__1.addTrailingSlash(norm) : norm));
-			var norm = "/" + Path__1.normalize((s1.charAt(0) == "/") ? HxOverrides.substr(s1, 1, null) : s1);
-			this.rootDir = (s1.lastIndexOf("/") == s1.length - 1) ? Path__1.addTrailingSlash(norm) : norm;
+			s = Path.posix.normalize(s);
+			s = StringTools.replace(s, "\\", "/");
+			var this1 = (SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s;
+			var s = this1.substring(0, this1.lastIndexOf("/") + 1);
+			s = Path.posix.normalize(s);
+			s = StringTools.replace(s, "\\", "/");
+			this.rootDir = (SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s;
 		} else {
 			var s = config.rootDir;
-			var norm = "/" + Path__1.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
-			this.rootDir = (s.lastIndexOf("/") == s.length - 1) ? Path__1.addTrailingSlash(norm) : norm;
+			s = Path.posix.normalize(s);
+			s = StringTools.replace(s, "\\", "/");
+			this.rootDir = (SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s;
 		};
 		this.cache = (config.cache == null) ? new CacheManager(this) : config.cache;
 		Project.projects.push(this);

package/bin/whet/Source.d.ts

@@ -35,12 +35,12 @@ export declare class SourceData {
 	/**
 	Same as `getFilePath` but relative to project, not CWD.
 	*/
-	getFilePathId(idOverride?: null | string): Promise<string>
+	protected getFilePathId(idOverride?: null | string): Promise<string>
 	
 	/**
 	Path to a file for this source, relative to CWD.
 	*/
-	getFilePath(idOverride?: null | string): Promise<string>
+	protected getFilePath(idOverride?: null | string): Promise<string>
 	
 	/**
 	* `path` is the actual cwd-relative path. `pathId` is the project-relative source Id.

package/bin/whet/Source.js

@@ -1,10 +1,12 @@
 import {Utils} from "./Utils.js"
-import {SourceId, RootDir} from "./SourceId.js"
+import {SourceId_Fields_, SourceId, RootDir} from "./SourceId.js"
 import {SourceHash} from "./SourceHash.js"
 import {Log} from "./Log.js"
+import * as Path from "path"
 import {Register} from "../genes/Register.js"
 import * as Fs from "fs"
 import {Buffer} from "buffer"
+import {StringTools} from "../StringTools.js"
 import {Lambda} from "../Lambda.js"
 
 const $global = Register.$global
@@ -42,8 +44,12 @@ class Source extends Register.inherits() {
 		if (id == null) {
 			return this.data[0];
 		} else {
+			var s = id;
+			s = Path.posix.normalize(id);
+			s = StringTools.replace(s, "\\", "/");
+			var sid = (SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s;
 			return Lambda.find(this.data, function (entry) {
-				return entry.id == id;
+				return entry.id == sid;
 			});
 		};
 	}
@@ -93,7 +99,10 @@ class SourceData extends Register.inherits() {
 			this.filePathId = SourceId.getPutInDir((idOverride != null) ? idOverride : this.id, dir);
 			var this1 = this.filePathId;
 			var root = RootDir.fromProject(this.source.origin.project);
-			this.filePath = (root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1;
+			if (this1.charAt(0) != "/") {
+				throw new Error("Badly formed SourceId.");
+			};
+			this.filePath = Path.posix.join(".", root, ".", this1);
 			return Utils.saveBytes(this.filePath, this.data).then(function (_) {
 				return _gthis.filePath;
 			});
@@ -114,7 +123,10 @@ class SourceData extends Register.inherits() {
 				} else {
 					var source = SourceData.fromBytes(id, buffer);
 					source.filePath = path;
-					source.filePathId = pathId;
+					var s = pathId;
+					s = Path.posix.normalize(s);
+					s = StringTools.replace(s, "\\", "/");
+					source.filePathId = (SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s;
 					res(source);
 				};
 			});
@@ -124,7 +136,10 @@ class SourceData extends Register.inherits() {
 		return SourceData.fromBytes(id, Buffer.from(s, "utf-8"));
 	}
 	static fromBytes(id, data) {
-		return new SourceData(id, data);
+		var s = id;
+		s = Path.posix.normalize(id);
+		s = StringTools.replace(s, "\\", "/");
+		return new SourceData((SourceId_Fields_.startsWithSlash(s)) ? s : "/" + s, data);
 	}
 	static get __name__() {
 		return "whet.SourceData"

package/bin/whet/SourceHash.d.ts

@@ -1,14 +1,20 @@
+import {MaybeArray} from "./magic/MaybeArray"
 import {Buffer} from "buffer"
 
 export declare class SourceHash {
 	protected constructor(bytes: Buffer)
 	protected bytes: Buffer
+	add(hash: SourceHash): SourceHash
 	toString(): string
 	static EMPTY: SourceHash
 	static fromFile(path: string): Promise<SourceHash>
+	
+	/**
+	* Creates hashes of all files and or content of directories, optionally recursive.
+	*/
+	static fromFiles(paths: MaybeArray<string>, filter?: null | ((arg0: string) => boolean), recursive?: boolean): Promise<SourceHash>
 	static fromBytes(data: Buffer): SourceHash
 	static fromString(data: string): SourceHash
-	static add(a: SourceHash, b: SourceHash): SourceHash
 	static equals(a: SourceHash, b: SourceHash): boolean
 	static toHex(hash: SourceHash): string
 	static fromHex(hex: string): SourceHash

package/bin/whet/SourceHash.js

@@ -1,3 +1,5 @@
+import {MaybeArray_Fields_} from "./magic/MaybeArray.js"
+import {Utils} from "./Utils.js"
 import {Register} from "../genes/Register.js"
 import * as Fs from "fs"
 import * as Crypto from "crypto"
@@ -10,6 +12,12 @@ class SourceHash extends Register.inherits() {
 	new(bytes) {
 		this.bytes = bytes;
 	}
+	add(hash) {
+		var data = Buffer.alloc(64);
+		this.bytes.copy(data, 0, 0, 32);
+		hash.bytes.copy(data, 32, 0, 32);
+		return SourceHash.fromBytes(data);
+	}
 	toString() {
 		return this.bytes.toString("hex");
 	}
@@ -24,18 +32,96 @@ class SourceHash extends Register.inherits() {
 			});
 		});
 	}
+	
+	/**
+	* Creates hashes of all files and or content of directories, optionally recursive.
+	*/
+	static fromFiles(paths, filter, recursive) {
+		if (recursive == null) {
+			recursive = true;
+		};
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = MaybeArray_Fields_.makeArray(paths);
+		while (_g1 < _g2.length) {
+			var src = [_g2[_g1]];
+			++_g1;
+			_g.push(new Promise((function (src) {
+				return function (res, rej) {
+					Fs.stat(src[0], (function (src) {
+						return function (err, stats) {
+							if (err != null) {
+								rej(err);
+							} else if (stats.isDirectory()) {
+								Utils.listDirectoryFiles(src[0], recursive).then((function () {
+									return function (files) {
+										res(files);
+									};
+								})());
+							} else {
+								res([src[0]]);
+							};
+						};
+					})(src));
+				};
+			})(src)));
+		};
+		var allFilesProm = _g;
+		return Promise.all(allFilesProm).then(function (arrFiles) {
+			var result = new Array(arrFiles.length);
+			var _g = 0;
+			var _g1 = arrFiles.length;
+			while (_g < _g1) {
+				var i = _g++;
+				var files = arrFiles[i];
+				if (filter != null) {
+					var _g2 = [];
+					var _g3 = 0;
+					var _g4 = files;
+					while (_g3 < _g4.length) {
+						var v = _g4[_g3];
+						++_g3;
+						if (filter(v)) {
+							_g2.push(v);
+						};
+					};
+					files = _g2;
+				};
+				files.sort();
+				var result1 = new Array(files.length);
+				var _g5 = 0;
+				var _g6 = files.length;
+				while (_g5 < _g6) {
+					var i1 = _g5++;
+					result1[i1] = SourceHash.fromFile(files[i1]);
+				};
+				result[i] = Promise.all(result1);
+			};
+			return result;
+		}).then(function (proms) {
+			return Promise.all(proms);
+		}).then(function (allHashes) {
+			var _g = [];
+			var _g_current = 0;
+			var _g_array = allHashes;
+			while (_g_current < _g_array.length) {
+				var e = _g_array[_g_current++];
+				var x = Register.iter(e);
+				while (x.hasNext()) {
+					var x1 = x.next();
+					_g.push(x1);
+				};
+			};
+			var this1 = _g;
+			return SourceHash.merge(...this1);
+		});
+	}
 	static fromBytes(data) {
 		return new SourceHash(Crypto.createHash("sha256").update(data).digest());
 	}
 	static fromString(data) {
 		return SourceHash.fromBytes(Buffer.from(data));
 	}
-	static add(a, b) {
-		var data = Buffer.alloc(64);
-		a.bytes.copy(data, 0, 0, 32);
-		b.bytes.copy(data, 32, 0, 32);
-		return SourceHash.fromBytes(data);
-	}
 	static equals(a, b) {
 		if (a != null && b != null) {
 			return a.bytes.compare(b.bytes) == 0;
@@ -65,7 +151,7 @@ class SourceHash extends Register.inherits() {
 		var h = hash[0];
 		var _g = 1;
 		var _g1 = hash.length;
-		while (_g < _g1) h = SourceHash.add(h, hash[_g++]);
+		while (_g < _g1) h = h.add(hash[_g++]);
 		return h;
 	}
 	static get __name__() {

package/bin/whet/SourceId.d.ts

@@ -8,3 +8,4 @@ export declare class SourceId {
 export declare class RootDir {
 	static fromProject(p: Project): string
 }
+