whet 0.0.34 → 0.1.1

package/bin/whet/route/RouteResult.js

@@ -4,15 +4,45 @@ const $global = Register.$global
 
 export const RouteResult = Register.global("$hxClasses")["whet.route.RouteResult"] = 
 class RouteResult extends Register.inherits() {
-	new(serveId, sourceId, source) {
+	[Register.new](serveId, sourceId, source) {
 		this.serveId = serveId;
 		this.sourceId = sourceId;
 		this.source = source;
 	}
 	get() {
-		let _gthis = this;
-		return this.source.getSource().then(function (data) {
-			return data.get(_gthis.sourceId);
+		return this.source.getPartialSource(this.sourceId).then(function (s) {
+			if (s != null) {
+				return s.get();
+			} else {
+				return null;
+			};
+		});
+	}
+	
+	/**
+	Get the raw Buffer directly.
+	*/
+	getData() {
+		return this.get().then(function (sd) {
+			return sd.data;
+		});
+	}
+	
+	/**
+	Get the output as a UTF-8 string.
+	*/
+	getString() {
+		return this.getData().then(function (d) {
+			return d.toString("utf-8");
+		});
+	}
+	
+	/**
+	Get the output parsed as JSON.
+	*/
+	getJson() {
+		return this.getString().then(function (s) {
+			return JSON.parse(s);
 		});
 	}
 	static get __name__() {
@@ -22,4 +52,7 @@ class RouteResult extends Register.inherits() {
 		return RouteResult
 	}
 }
+RouteResult.prototype.serveId = null;
+RouteResult.prototype.sourceId = null;
+RouteResult.prototype.source = null;
 

package/bin/whet/route/Router.d.ts

@@ -3,13 +3,19 @@ import {RoutePathType} from "../magic/RoutePathType"
 import {MinimatchType} from "../magic/MinimatchType"
 import {OutputFilter, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
+import {Buffer} from "buffer"
 
 export declare class Router {
 	constructor(routes?: null | RoutePathType)
 	protected routes: RoutePath[]
 	route(r: RoutePathType): void
 	
+	/**
+	Recursively collect all Stone IDs referenced in this Router's routes.
+	*/
+	collectStoneIds(): string[]
+	
 	/**
 	* Find data sources routed under `pattern`.
 	* @param pattern A glob pattern to search for.
@@ -27,6 +33,21 @@ export declare class Router {
 	* Save files filtered by `pattern` into provided `saveInto` folder.
 	*/
 	saveInto(pattern: MinimatchType, saveInto: string, clearFirst?: boolean): Promise<any>
+	
+	/**
+	Get the raw Buffer of the first matching result.
+	*/
+	getData(pattern?: null | MinimatchType): Promise<Buffer>
+	
+	/**
+	Get the first matching result as a UTF-8 string.
+	*/
+	getString(pattern?: null | MinimatchType): Promise<string>
+	
+	/**
+	Get the first matching result parsed as JSON.
+	*/
+	getJson(pattern?: null | MinimatchType): Promise<any>
 	listContents(pattern?: null | MinimatchType): Promise<string>
 	
 	/**
@@ -44,6 +65,11 @@ export type Filter = {
 }
 
 export declare class Filters {
+	
+	/**
+	Like finalize, but restores filter state afterwards. Returns serveId on match, null otherwise.
+	*/
+	static tryFinalize($this: Filter[], finalPath: string): null | string
 	protected static isPathPossible($this: Filter[], f: Filter): boolean
 }
 

package/bin/whet/route/Router.js

@@ -12,7 +12,7 @@ const $global = Register.$global
 
 export const Router = Register.global("$hxClasses")["whet.route.Router"] = 
 class Router extends Register.inherits() {
-	new(routes) {
+	[Register.new](routes) {
 		this.routes = (routes != null) ? RoutePathType_Fields_.makeRoutePath(routes) : [];
 	}
 	route(r) {
@@ -21,6 +21,36 @@ class Router extends Register.inherits() {
 		while (_g < _g1.length) this.routes.push(_g1[_g++]);
 	}
 	
+	/**
+	Recursively collect all Stone IDs referenced in this Router's routes.
+	*/
+	collectStoneIds() {
+		let ids = [];
+		let _g = 0;
+		let _g1 = this.routes;
+		while (_g < _g1.length) {
+			let route = _g1[_g];
+			++_g;
+			if (((route.source) instanceof Stone)) {
+				let id = route.source.id;
+				if (ids.indexOf(id) == -1) {
+					ids.push(id);
+				};
+			} else if (((route.source) instanceof Router)) {
+				let _g = 0;
+				let _g1 = route.source.collectStoneIds();
+				while (_g < _g1.length) {
+					let id = _g1[_g];
+					++_g;
+					if (ids.indexOf(id) == -1) {
+						ids.push(id);
+					};
+				};
+			};
+		};
+		return ids;
+	}
+	
 	/**
 	* Find data sources routed under `pattern`.
 	* @param pattern A glob pattern to search for.
@@ -45,7 +75,7 @@ class Router extends Register.inherits() {
 				while (_g2 < _g3) {
 					let i = _g2++;
 					let f = mainFilters[i];
-					result[i] = {"filter": f.filter, "pathSoFar": f.pathSoFar.slice(), "inProgress": f.inProgress, "remDirs": f.remDirs.slice()};
+					result[i] = {"filter": f.filter, "pathSoFar": f.pathSoFar, "inProgress": f.inProgress, "remDirs": f.remDirs};
 				};
 				let routeFilters = result;
 				let possible;
@@ -126,7 +156,10 @@ class Router extends Register.inherits() {
 					let f = route.filter;
 					let extractDir = route.extractDirs;
 					if (extractDir != null && routeFilters.length > 0) {
-						routeFilters[routeFilters.length - 1].remDirs.push(extractDir);
+						let routeFilters1 = routeFilters;
+						let tmp = routeFilters.length - 1;
+						let tmp1 = routeFilters[routeFilters.length - 1].remDirs.concat([extractDir]);
+						routeFilters1[tmp].remDirs = tmp1;
 					};
 					routeFilters.push({"pathSoFar": [], "filter": f, "inProgress": true, "remDirs": []});
 				};
@@ -145,47 +178,13 @@ class Router extends Register.inherits() {
 				let prom;
 				if (((route.source) instanceof Stone)) {
 					let stone = route.source;
-					prom = stone.list().then(function (list) {
+					prom = stone.listIds().then(function (list) {
 						let _g = 0;
 						while (_g < list.length) {
 							let sourceId = list[_g];
 							++_g;
-							let result = new Array(routeFilters.length);
-							let _g1 = 0;
-							let _g2 = routeFilters.length;
-							while (_g1 < _g2) {
-								let i = _g1++;
-								let f = routeFilters[i];
-								result[i] = {"filter": f.filter, "pathSoFar": f.pathSoFar.slice(), "inProgress": f.inProgress, "remDirs": f.remDirs.slice()};
-							};
-							let finalFilters = result;
-							let parts = sourceId.split("/");
-							let res = true;
-							let i = finalFilters.length;
-							while (--i >= 0) {
-								let f = finalFilters[i];
-								if (f.inProgress) {
-									f.inProgress = false;
-									if (f.remDirs.length != 0) {
-										let i = parts.length;
-										while (--i >= 0) {
-											let _g = 0;
-											let _g1 = f.remDirs;
-											while (_g < _g1.length) if (_g1[_g++].match(parts[i] + "/")) {
-												parts.splice(i, 1);
-												break;
-											};
-										};
-									};
-									f.pathSoFar = f.pathSoFar.concat(parts);
-									if (!(f.filter == null || f.filter.match(Path.posix.join(...f.pathSoFar)))) {
-										res = false;
-										break;
-									};
-								};
-							};
-							if (res) {
-								let serveId = Path.posix.join(...finalFilters[0].pathSoFar);
+							let serveId = Filters.tryFinalize(routeFilters, sourceId);
+							if (serveId != null) {
 								results.push(new RouteResult(serveId, sourceId, stone));
 							};
 						};
@@ -275,6 +274,33 @@ class Router extends Register.inherits() {
 			return Promise.all(_g);
 		});
 	}
+	
+	/**
+	Get the raw Buffer of the first matching result.
+	*/
+	getData(pattern) {
+		return this.get(pattern).then(function (r) {
+			return r[0].getData();
+		});
+	}
+	
+	/**
+	Get the first matching result as a UTF-8 string.
+	*/
+	getString(pattern) {
+		return this.get(pattern).then(function (r) {
+			return r[0].getString();
+		});
+	}
+	
+	/**
+	Get the first matching result parsed as JSON.
+	*/
+	getJson(pattern) {
+		return this.get(pattern).then(function (r) {
+			return r[0].getJson();
+		});
+	}
 	listContents(pattern) {
 		return this.get(pattern).then(function (files) {
 			let result = new Array(files.length);
@@ -352,10 +378,95 @@ class Router extends Register.inherits() {
 		return Router
 	}
 }
+Router.prototype.routes = null;
 
 
 export const Filters = Register.global("$hxClasses")["whet.route._Router.Filters"] = 
 class Filters {
+	
+	/**
+	Like finalize, but restores filter state afterwards. Returns serveId on match, null otherwise.
+	*/
+	static tryFinalize(this1, finalPath) {
+		if (this1.length == 1) {
+			let f = this1[0];
+			let savedPath = f.pathSoFar;
+			let savedIP = f.inProgress;
+			let parts = finalPath.split("/");
+			let res = true;
+			let i = this1.length;
+			while (--i >= 0) {
+				let f = this1[i];
+				if (f.inProgress) {
+					f.inProgress = false;
+					if (f.remDirs.length != 0) {
+						let i = parts.length;
+						while (--i >= 0) {
+							let _g = 0;
+							let _g1 = f.remDirs;
+							while (_g < _g1.length) if (_g1[_g++].match(parts[i] + "/")) {
+								parts.splice(i, 1);
+								break;
+							};
+						};
+					};
+					f.pathSoFar = f.pathSoFar.concat(parts);
+					if (!(f.filter == null || f.filter.match(Path.posix.join(...f.pathSoFar)))) {
+						res = false;
+						break;
+					};
+				};
+			};
+			let serveId = (res) ? Path.posix.join(...this1[0].pathSoFar) : null;
+			f.pathSoFar = savedPath;
+			f.inProgress = savedIP;
+			return serveId;
+		};
+		let arr = this1;
+		let _g = [];
+		let _g1 = 0;
+		while (_g1 < arr.length) {
+			let f = arr[_g1];
+			++_g1;
+			_g.push({"p": f.pathSoFar, "ip": f.inProgress});
+		};
+		let parts = finalPath.split("/");
+		let res = true;
+		let i = this1.length;
+		while (--i >= 0) {
+			let f = this1[i];
+			if (f.inProgress) {
+				f.inProgress = false;
+				if (f.remDirs.length != 0) {
+					let i = parts.length;
+					while (--i >= 0) {
+						let _g = 0;
+						let _g1 = f.remDirs;
+						while (_g < _g1.length) if (_g1[_g++].match(parts[i] + "/")) {
+							parts.splice(i, 1);
+							break;
+						};
+					};
+				};
+				f.pathSoFar = f.pathSoFar.concat(parts);
+				if (!(f.filter == null || f.filter.match(Path.posix.join(...f.pathSoFar)))) {
+					res = false;
+					break;
+				};
+			};
+		};
+		let serveId = (res) ? Path.posix.join(...this1[0].pathSoFar) : null;
+		let i1 = 0;
+		let _g2 = 0;
+		while (_g2 < arr.length) {
+			let f = arr[_g2];
+			++_g2;
+			f.pathSoFar = _g[i1].p;
+			f.inProgress = _g[i1].ip;
+			++i1;
+		};
+		return serveId;
+	}
 	static isPathPossible(this1, f) {
 		if (f.filter.options.matchBase) {
 			return true;

package/bin/whet/stones/Files.d.ts

@@ -5,12 +5,13 @@ import {Stone, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
 import {SourceData} from "../Source"
 import {Project} from "../Project"
+import {ConfigStore} from "../ConfigStore"
 
 export declare class Files extends Stone<FilesConfig> {
 	constructor(config: FilesConfig)
 	protected initConfig(): void
 	protected generateHash(): Promise<SourceHash>
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
 	protected generate(hash: SourceHash): Promise<SourceData[]>
 	protected walk<T>(onFile: ((arg0: string) => T), onDirFile: ((arg0: string, arg1: string) => T)): Promise<T[]>
 	protected fromCwd(file: string, dir: string): {
@@ -27,6 +28,10 @@ export type FilesConfig = {
 	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
+	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
 	* that use a source of some stone, but don't go via Whet to get it.
 	* Use with combination of `setAbsolutePath` on the dependency, so that the external process

package/bin/whet/stones/Files.js

@@ -11,11 +11,12 @@ const $global = Register.$global
 
 export const Files = Register.global("$hxClasses")["whet.stones.Files"] = 
 class Files extends Register.inherits(() => Stone, true) {
-	new(config) {
-		super.new(config);
+	[Register.new](config) {
+		super[Register.new](config);
 	}
 	initConfig() {
 		this.config.recursive = (this.config.recursive != null) ? this.config.recursive : true;
+		this.config.id = (this.config.id != null) ? this.config.id : MaybeArray_Fields_.makeArray(this.config.paths)[0];
 	}
 	generateHash() {
 		let hashCache = HashCache.get();

package/bin/whet/stones/JsonStone.d.ts

@@ -6,6 +6,7 @@ import {Stone, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
 import {SourceData} from "../Source"
 import {Project} from "../Project"
+import {ConfigStore} from "../ConfigStore"
 
 export declare class JsonStone extends Stone<JsonStoneConfig> {
 	constructor(config: JsonStoneConfig)
@@ -13,7 +14,7 @@ export declare class JsonStone extends Stone<JsonStoneConfig> {
 	addProjectData(): JsonStone
 	protected generate(hash: SourceHash): Promise<SourceData[]>
 	protected generateHash(): Promise<SourceHash>
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
 	protected initConfig(): void
 }
 
@@ -25,6 +26,10 @@ export type JsonStoneConfig = {
 	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
+	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
 	* that use a source of some stone, but don't go via Whet to get it.
 	* Use with combination of `setAbsolutePath` on the dependency, so that the external process

package/bin/whet/stones/JsonStone.js

@@ -9,9 +9,9 @@ const $global = Register.$global
 
 export const JsonStone = Register.global("$hxClasses")["whet.stones.JsonStone"] = 
 class JsonStone extends Register.inherits(Stone) {
-	new(config) {
+	[Register.new](config) {
 		this.data = {};
-		super.new(config);
+		super[Register.new](config);
 	}
 	addProjectData() {
 		this.data["name"] = this.project.name;
@@ -80,4 +80,5 @@ class JsonStone extends Register.inherits(Stone) {
 		return JsonStone
 	}
 }
+JsonStone.prototype.data = null;
 

package/bin/whet/stones/RemoteFile.d.ts

@@ -5,13 +5,14 @@ import {Stone, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
 import {SourceData} from "../Source"
 import {Project} from "../Project"
+import {ConfigStore} from "../ConfigStore"
 
 export declare class RemoteFile extends Stone<RemoteFileConfig> {
 	constructor(config: RemoteFileConfig)
 	protected initConfig(): void
 	protected generate(hash: SourceHash): Promise<SourceData[]>
-	protected get(url: string, res: ((arg0: SourceData[]) => void), rej: ((reason: any) => void)): void
-	list(): Promise<string[]>
+	protected get(url: string, res: ((arg0: SourceData[]) => void), rej: ((arg0: Error) => void)): void
+	protected list(): Promise<null | string[]>
 	generateHash(): Promise<SourceHash>
 	protected getId(): string
 }
@@ -24,6 +25,10 @@ export type RemoteFileConfig = {
 	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
+	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
 	* that use a source of some stone, but don't go via Whet to get it.
 	* Use with combination of `setAbsolutePath` on the dependency, so that the external process

package/bin/whet/stones/RemoteFile.js

@@ -13,8 +13,8 @@ const $global = Register.$global
 
 export const RemoteFile = Register.global("$hxClasses")["whet.stones.RemoteFile"] = 
 class RemoteFile extends Register.inherits(Stone) {
-	new(config) {
-		super.new(config);
+	[Register.new](config) {
+		super[Register.new](config);
 	}
 	initConfig() {
 		if (this.config.cacheStrategy == null) {
@@ -30,24 +30,27 @@ class RemoteFile extends Register.inherits(Stone) {
 	}
 	get(url, res, rej) {
 		let _gthis = this;
-		Https.get(url, function (response) {
+		let req = Https.get(url, function (response) {
 			if (response.statusCode == 301 || response.statusCode == 302) {
 				_gthis.get(response.headers["location"], res, rej);
 				return;
 			};
 			if (response.statusCode < 200 || response.statusCode >= 300) {
 				response.resume();
-				throw new Error("Error downloading file. " + response.statusCode + " – " + response.statusMessage);
+				rej(new Error("Error downloading file. " + response.statusCode + " – " + response.statusMessage));
+				return;
 			};
 			let bufs = [];
 			response.on("data", function (d) {
 				return bufs.push(d);
 			});
+			response.on("error", rej);
 			response.on("end", function () {
 				let data = Buffer.concat(bufs);
 				res([SourceData.fromBytes(_gthis.getId(), data)]);
 			});
 		});
+		req.on("error", rej);
 	}
 	list() {
 		return Promise.resolve([this.getId()]);

package/bin/whet/stones/Zip.d.ts

@@ -6,6 +6,7 @@ import {Stone, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
 import {SourceData} from "../Source"
 import {Project} from "../Project"
+import {ConfigStore} from "../ConfigStore"
 
 export declare class ZipStone extends Stone<ZipConfig> {
 	constructor(config: ZipConfig)
@@ -16,7 +17,7 @@ export declare class ZipStone extends Stone<ZipConfig> {
 	*/
 	protected generateHash(): Promise<SourceHash>
 	protected generate(hash: SourceHash): Promise<SourceData[]>
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
 }
 
 export type ZipConfig = {
@@ -27,6 +28,10 @@ export type ZipConfig = {
 	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
+	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
 	* that use a source of some stone, but don't go via Whet to get it.
 	* Use with combination of `setAbsolutePath` on the dependency, so that the external process

package/bin/whet/stones/Zip.js

@@ -17,8 +17,8 @@ const $global = Register.$global
 
 export const ZipStone = Register.global("$hxClasses")["whet.stones.ZipStone"] = 
 class ZipStone extends Register.inherits(Stone) {
-	new(config) {
-		super.new(config);
+	[Register.new](config) {
+		super[Register.new](config);
 	}
 	initConfig() {
 		if (this.config.filename == null) {

package/bin/whet/stones/haxe/HaxeBuild.d.ts

@@ -6,6 +6,7 @@ import {Stone, AnyStone} from "../../Stone"
 import {SourceHash} from "../../SourceHash"
 import {SourceData} from "../../Source"
 import {Project} from "../../Project"
+import {ConfigStore} from "../../ConfigStore"
 
 export declare class HaxeBuild extends Stone<BuildConfig> {
 	constructor(config: BuildConfig)
@@ -17,7 +18,7 @@ export declare class HaxeBuild extends Stone<BuildConfig> {
 	build(): Promise<any>
 	protected generate(hash: SourceHash): Promise<SourceData[]>
 	protected addCommands(): void
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
 	protected generateHash(): Promise<SourceHash>
 }
 
@@ -28,6 +29,10 @@ export type BuildConfig = {
 	* After stone is initialized, change `stone.cacheStrategy` directly.
 	*/
 	cacheStrategy?: null | CacheStrategy, 
+	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
 	cwd?: null | string, 
 	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
@@ -40,6 +45,7 @@ export type BuildConfig = {
 	* Do not create cyclic dependencies!
 	*/
 	dependencies?: null | MaybeArray<AnyStone>, 
+	exposeCommands?: null | boolean, 
 	filename?: null | string, 
 	hxml: Hxml, 
 	/**

package/bin/whet/stones/haxe/HaxeBuild.js

@@ -14,8 +14,8 @@ const $global = Register.$global
 
 export const HaxeBuild = Register.global("$hxClasses")["whet.stones.haxe.HaxeBuild"] = 
 class HaxeBuild extends Register.inherits(Stone) {
-	new(config) {
-		super.new(config);
+	[Register.new](config) {
+		super[Register.new](config);
 	}
 	initConfig() {
 		if (this.config.cacheStrategy == null) {
@@ -78,15 +78,17 @@ class HaxeBuild extends Register.inherits(Stone) {
 	}
 	addCommands() {
 		let _gthis = this;
-		this.project.addCommand("build", this).action(function (..._) {
-			return _gthis.project.cache.refreshSource(_gthis);
-		});
+		if (this.config.exposeCommands != false) {
+			this.project.addCommand("build", this).action(function (..._) {
+				return _gthis.project.cache.refreshSource(_gthis);
+			});
+		};
 	}
 	list() {
 		if (this.config.hxml.isSingleFile()) {
 			return Promise.resolve([this.config.hxml.getBuildFilename()]);
 		} else {
-			return super.list();
+			return Promise.resolve(null);
 		};
 	}
 	generateHash() {

package/bin/whet/stones/haxe/Hxml.d.ts

@@ -6,6 +6,7 @@ import {Stone, AnyStone} from "../../Stone"
 import {SourceHash} from "../../SourceHash"
 import {SourceData} from "../../Source"
 import {Project} from "../../Project"
+import {ConfigStore} from "../../ConfigStore"
 
 export declare class Hxml extends Stone<HxmlConfig> {
 	constructor(config: HxmlConfig)
@@ -22,7 +23,7 @@ export declare class Hxml extends Stone<HxmlConfig> {
 	isSingleFile(): boolean
 	getBuildExtension(): string
 	protected generate(hash: SourceHash): Promise<SourceData[]>
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
 	protected filename(): string
 	generateHash(): Promise<SourceHash>
 	generateHashSync(): SourceHash
@@ -36,6 +37,10 @@ export type HxmlConfig = {
 	* After stone is initialized, change `stone.cacheStrategy` directly.
 	*/
 	cacheStrategy?: null | CacheStrategy, 
+	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
 	dce?: null | DCE, 
 	debug?: null | boolean, 
 	defines?: null | MaybeArray<string>, 
@@ -50,6 +55,7 @@ export type HxmlConfig = {
 	* Do not create cyclic dependencies!
 	*/
 	dependencies?: null | MaybeArray<AnyStone>, 
+	exposeCommands?: null | boolean, 
 	flags?: null | MaybeArray<MaybeArray<string>>, 
 	/**
 	Defaults to the Stone's class name.