whet 0.0.3 → 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/Log.d.ts

@@ -0,0 +1,33 @@
+import {PosInfos} from "./PosInfos"
+
+/**
+Log primarily provides the `trace()` method, which is invoked upon a call to
+`trace()` in Haxe code.
+*/
+export declare class Log {
+	
+	/**
+	Format the output of `trace` before printing it.
+	*/
+	static formatOutput(v: any, infos: PosInfos): string
+	
+	/**
+	Outputs `v` in a platform-dependent way.
+	
+	The second parameter `infos` is injected by the compiler and contains
+	information about the position where the `trace()` call was made.
+	
+	This method can be rebound to a custom function:
+	
+	var oldTrace = haxe.Log.trace; // store old function
+	haxe.Log.trace = function(v, ?infos) {
+	// handle trace
+	}
+	...
+	haxe.Log.trace = oldTrace;
+	
+	If it is bound to null, subsequent calls to `trace()` will cause an
+	exception.
+	*/
+	static trace(v: any, infos?: null | PosInfos): void
+}

package/bin/haxe/Log.js

@@ -0,0 +1,61 @@
+import {Register} from "../genes/Register.js"
+import {Std} from "../Std.js"
+
+const $global = Register.$global
+
+/**
+Log primarily provides the `trace()` method, which is invoked upon a call to
+`trace()` in Haxe code.
+*/
+export const Log = Register.global("$hxClasses")["haxe.Log"] = 
+class Log {
+	
+	/**
+	Format the output of `trace` before printing it.
+	*/
+	static formatOutput(v, infos) {
+		var str = Std.string(v);
+		if (infos == null) {
+			return str;
+		};
+		var pstr = infos.fileName + ":" + infos.lineNumber;
+		if (infos.customParams != null) {
+			var _g = 0;
+			var _g1 = infos.customParams;
+			while (_g < _g1.length) str += ", " + Std.string(_g1[_g++]);
+		};
+		return pstr + ": " + str;
+	}
+	
+	/**
+	Outputs `v` in a platform-dependent way.
+	
+	The second parameter `infos` is injected by the compiler and contains
+	information about the position where the `trace()` call was made.
+	
+	This method can be rebound to a custom function:
+	
+	var oldTrace = haxe.Log.trace; // store old function
+	haxe.Log.trace = function(v, ?infos) {
+	// handle trace
+	}
+	...
+	haxe.Log.trace = oldTrace;
+	
+	If it is bound to null, subsequent calls to `trace()` will cause an
+	exception.
+	*/
+	static trace(v, infos) {
+		var str = Log.formatOutput(v, infos);
+		if (typeof(console) != "undefined" && console.log != null) {
+			console.log(str);
+		};
+	}
+	static get __name__() {
+		return "haxe.Log"
+	}
+	get __class__() {
+		return Log
+	}
+}
+

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);
@@ -34,16 +34,21 @@ class Project extends Register.inherits() {
 			};
 			var file = new Error().stack[3].getFileName();
 			Error.prepareStackTrace = oldValue;
+			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,13 +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