whet 0.0.13 → 0.0.16

package/bin/whet/Source.d.ts

@@ -39,12 +39,14 @@ export declare class SourceData {
 	/**
 	Same as `getFilePath` but relative to project, not CWD.
 	*/
-	protected getFilePathId(idOverride?: null | string): Promise<string>
+	getFilePathId(idOverride?: null | string): Promise<string>
 	
 	/**
-	Path to a file for this source, relative to CWD.
+	* Path to a file for this source, relative to CWD.
+	* Useful for working with sources outside of Whet ecosystem.
+	* @param [idOverride] Use to change the name/directory of the file. Ignored if source already has a filepath.
 	*/
-	protected getFilePath(idOverride?: null | string): Promise<string>
+	getFilePath(idOverride?: null | string): Promise<string>
 	
 	/**
 	* @param id Path id relative to stone that generates it.

package/bin/whet/Source.js

@@ -92,7 +92,9 @@ class SourceData extends Register.inherits() {
 	}
 	
 	/**
-	Path to a file for this source, relative to CWD.
+	* Path to a file for this source, relative to CWD.
+	* Useful for working with sources outside of Whet ecosystem.
+	* @param [idOverride] Use to change the name/directory of the file. Ignored if source already has a filepath.
 	*/
 	getFilePath(idOverride) {
 		var _gthis = this;
@@ -101,7 +103,7 @@ class SourceData extends Register.inherits() {
 				new Error("Data without source.");
 			};
 			var dir = this.source.getDirPath();
-			this.filePathId = SourceId.getPutInDir((idOverride != null) ? idOverride : this.id, dir);
+			this.filePathId = SourceId.getPutInDir((idOverride != null && HxOverrides.cca(idOverride, idOverride.length - 1) != 47) ? idOverride : this.id, dir);
 			var this1 = this.filePathId;
 			var root = RootDir.fromProject(this.source.origin.project);
 			if (this1.charAt(0) != "/") {

package/bin/whet/Stone.d.ts

@@ -57,6 +57,13 @@ export declare class Stone<T extends StoneConfig> {
 	*/
 	protected generateSource(hash: null | SourceHash): Promise<Source>
 	
+	/**
+	* To be used externally (i.e. `myStone.handleError = err => ...`) for providing a fallback value
+	* where it might make sense.
+	* @param err Any error that might have happened during `generateSource`.
+	*/
+	handleError(err: any): Promise<SourceData[]>
+	
 	/**
 	* Optionally overridable hash generation as optimization.
 	* Do not use directly. Use `getHash` instead.
@@ -113,6 +120,11 @@ export declare class Stone<T extends StoneConfig> {
 }
 
 export type StoneConfig = {
+	/**
+	* Defaults to `project.cache.defaultStrategy`.
+	* **Do not modify after initialization – it is ignored.**
+	* After stone is initialized, change `stone.cacheStrategy` directly.
+	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes

package/bin/whet/Stone.js

@@ -140,9 +140,30 @@ class Stone extends Register.inherits() {
 			} else {
 				return null;
 			};
+		})["catch"](function (e) {
+			return _gthis.handleError(e).then(function (data) {
+				Log.log(40, ...["Error happened and was handled by `handleError`.", {"stone": _gthis, "error": e}]);
+				var result = new Array(data.length);
+				var _g = 0;
+				var _g1 = data.length;
+				while (_g < _g1) {
+					var i = _g++;
+					result[i] = SourceHash.fromBytes(data[i].data);
+				};
+				return new Source(data, SourceHash.merge(...result), _gthis, Date.now() / 1000);
+			});
 		});
 	}
 	
+	/**
+	* To be used externally (i.e. `myStone.handleError = err => ...`) for providing a fallback value
+	* where it might make sense.
+	* @param err Any error that might have happened during `generateSource`.
+	*/
+	handleError(err) {
+		return Promise.reject(err);
+	}
+	
 	/**
 	* Optionally overridable hash generation as optimization.
 	* Do not use directly. Use `getHash` instead.

package/bin/whet/Utils.js

@@ -53,7 +53,7 @@ class Utils {
 	Saves bytes Buffer, creates missing directories if needed.
 	*/
 	static saveBytes(path, bytes) {
-		Log.log(10, ...["Writing bytes to " + path + "."]);
+		Log.log(10, ...["Writing bytes to \"" + path + "\"."]);
 		return Utils.ensureDirExist(Path.dirname(path)).then(function (_) {
 			return new Promise(function (res, rej) {
 				Fs.writeFile(path, bytes, function (err) {

package/bin/whet/Whet.js

@@ -10,7 +10,7 @@ const $global = Register.$global
 export const Whet_Fields_ = Register.global("$hxClasses")["whet._Whet.Whet_Fields_"] = 
 class Whet_Fields_ {
 	static main() {
-		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.0.13", "-v, --version").allowUnknownOption(true).showSuggestionAfterError(true).option("-p, --project <file>", "project to run", "Project.mjs").option("-l, --log-level <level>", "log level, a string/number", "info");
+		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.0.16", "-v, --version").allowUnknownOption(true).showSuggestionAfterError(true).option("-p, --project <file>", "project to run", "Project.mjs").option("-l, --log-level <level>", "log level, a string/number", "info");
 		Whet_Fields_.program.parse();
 		var options = Whet_Fields_.program.opts();
 		if (options.logLevel != null) {

package/bin/whet/extern/Minimatch.d.ts

@@ -0,0 +1,77 @@
+
+export type IOptions = {
+	/**
+	Dump a ton of stuff to stderr.
+	*/
+	debug?: null | boolean, 
+	/**
+	Allow patterns to match filenames starting with a period,
+	even if the pattern does not explicitly have a period in that spot.
+	
+	Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
+	*/
+	dot?: null | boolean, 
+	/**
+	Returns from negate expressions the same as if they were not negated.
+	(Ie, true on a hit, false on a miss.)
+	*/
+	flipNegate?: null | boolean, 
+	/**
+	If set, then patterns without slashes will be matched
+	against the basename of the path if it contains slashes. For example,
+	`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+	*/
+	matchBase?: null | boolean, 
+	/**
+	Do not expand `{a,b}` and `{1..3}` brace sets.
+	*/
+	nobrace?: null | boolean, 
+	/**
+	Perform a case-insensitive match.
+	*/
+	nocase?: null | boolean, 
+	/**
+	Suppress the behavior of treating `#` at the start of a pattern as a comment.
+	*/
+	nocomment?: null | boolean, 
+	/**
+	Disable "extglob" style patterns like `+(a|b)`.
+	*/
+	noext?: null | boolean, 
+	/**
+	Disable `**` matching against multiple folder names.
+	*/
+	noglobstar?: null | boolean, 
+	/**
+	Suppress the behavior of treating a leading `!` character as negation.
+	*/
+	nonegate?: null | boolean, 
+	/**
+	When a match is not found by `minimatch.match`,
+	return a list containing the pattern itself if this option is set.
+	Otherwise, an empty list is returned if there are no matches.
+	*/
+	nonull?: null | boolean, 
+	/**
+	Compare a partial path to a pattern.  As long as the parts of the path that
+	are present are not contradicted by the pattern, it will be treated as a
+	match. This is useful in applications where you're walking through a
+	folder structure, and don't yet have the full path, but want to ensure that
+	you do not walk down paths that can never be a match.
+	*/
+	partial?: null | boolean, 
+	/**
+	Use `\\` as a path separator _only_, and _never_ as an escape
+	character. If set, all `\\` characters are replaced with `/` in
+	the pattern. Note that this makes it **impossible** to match
+	against paths containing literal glob pattern characters, but
+	allows matching with patterns constructed using `path.join()` and
+	`path.resolve()` on Windows platforms, mimicking the (buggy!)
+	behavior of earlier versions on Windows. Please use with
+	caution, and be mindful of the caveat about Windows paths
+	
+	For legacy reasons, this is also set if
+	`options.allowWindowsEscape` is set to the exact value `false`.
+	*/
+	windowsPathsNoEscape?: null | boolean
+}

package/bin/whet/magic/MinimatchType.d.ts

@@ -0,0 +1,5 @@
+import Minimatch from "minimatch"
+
+export type MinimatchType = Minimatch | string
+
+export const makeMinimatch: (src: MinimatchType) => Minimatch

package/bin/whet/magic/MinimatchType.js

@@ -0,0 +1,26 @@
+import Minimatch from "minimatch"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const MinimatchType_Fields_ = Register.global("$hxClasses")["whet.magic._MinimatchType.MinimatchType_Fields_"] = 
+class MinimatchType_Fields_ {
+	static makeMinimatch(src) {
+		if (typeof(src) == "string") {
+			return new Minimatch.Minimatch(src, null);
+		} else if (src instanceof Minimatch.Minimatch) {
+			return src;
+		} else {
+			throw new Error("Expected a string or Minimatch object.");
+		};
+	}
+	static get __name__() {
+		return "whet.magic._MinimatchType.MinimatchType_Fields_"
+	}
+	get __class__() {
+		return MinimatchType_Fields_
+	}
+}
+
+
+export const makeMinimatch = MinimatchType_Fields_.makeMinimatch

package/bin/whet/magic/RoutePathType.d.ts

@@ -1,9 +1,18 @@
 import {Router, RoutePath} from "../route/Router"
-import {BaseRouteType} from "./RouteType"
+import {MinimatchType} from "./MinimatchType"
+import {AnyStone} from "../Stone"
 
 /**
-* Anything that can be transformed into `Route`.
+* Anything that can be transformed into `RoutePath`. Can be a Stone or Router.
+* Can also be an array of Stones, Routers, or:
+* - `[routeUnder, Stone|Router]`, where `routeUnder` is a string to serve the results under (directory or filename).
+* - `[routeUnder, Stone|Router, filter]`, where `filter` can be a glob pattern string, or a `Minimatch` object.
+* - `[routeUnder, Stone|Router, filter, extractDirs]`, where `extractDirs` can be a glob pattern,
+* or a `Minimatch` object, and is used to remove the portion of results' directory that matches.
+* Wherever Stone or Router is expected, a string can be used as a shortcut for `new Files({ paths: [<string>] })`.
 */
-export type RoutePathType = Router | BaseRouteType[][]
+export type RoutePathType = BaseRouteType | BaseRouteType[] | BaseRouteType[][]
+
+export type BaseRouteType = Router | AnyStone | MinimatchType | string
 
 export const makeRoutePath: (routerPathType: RoutePathType) => RoutePath[]

package/bin/whet/magic/RoutePathType.js

@@ -1,7 +1,9 @@
+import {Files} from "../stones/Files.js"
 import {Router} from "../route/Router.js"
-import {Route} from "../route/Route.js"
-import {RouteType_Fields_} from "./RouteType.js"
+import {MinimatchType_Fields_} from "./MinimatchType.js"
+import {Stone} from "../Stone.js"
 import * as Path from "path"
+import Minimatch from "minimatch"
 import {Register} from "../../genes/Register.js"
 import {StringTools} from "../../StringTools.js"
 import {HxOverrides} from "../../HxOverrides.js"
@@ -11,11 +13,18 @@ const $global = Register.$global
 export const RoutePathType_Fields_ = Register.global("$hxClasses")["whet.magic._RoutePathType.RoutePathType_Fields_"] = 
 class RoutePathType_Fields_ {
 	static makeRoutePath(routerPathType) {
-		if (((routerPathType) instanceof Router)) {
-			return routerPathType.routes;
+		if (((routerPathType) instanceof Router) || ((routerPathType) instanceof Stone) || typeof(routerPathType) == "string") {
+			var s = "/";
+			var str = ("/".length > 1 && HxOverrides.cca("/", 0) == 47) ? "/".substring(1) : "/";
+			if (str.length > 0) {
+				str = Path.posix.normalize(str);
+				str = StringTools.replace(str, "\\", "/");
+			};
+			s = str;
+			return [{"routeUnder": (HxOverrides.cca(s, 0) == 47) ? s : "/" + s, "source": (typeof(routerPathType) == "string") ? new Files({"paths": [routerPathType]}) : routerPathType, "filter": null, "extractDirs": null}];
 		};
 		if (!((routerPathType) instanceof Array)) {
-			throw new Error("RoutePath should be an array.");
+			throw new Error("RoutePath should be a Stone, Router, or an array.");
 		};
 		var _g = [];
 		var _g1 = 0;
@@ -23,25 +32,80 @@ class RoutePathType_Fields_ {
 		while (_g1 < _g2.length) {
 			var item = _g2[_g1];
 			++_g1;
-			if (!((item) instanceof Array)) {
-				throw new Error("RoutePath element should be an array.");
-			};
-			if (item.length < 2) {
-				throw new Error("RoutePath element should have at least 2 entries `[serveId, route]`.");
+			if (((item) instanceof Router) || ((item) instanceof Stone) || typeof(item) == "string") {
+				var s = "/";
+				var str = ("/".length > 1 && HxOverrides.cca("/", 0) == 47) ? "/".substring(1) : "/";
+				if (str.length > 0) {
+					str = Path.posix.normalize(str);
+					str = StringTools.replace(str, "\\", "/");
+				};
+				s = str;
+				_g.push({"routeUnder": (HxOverrides.cca(s, 0) == 47) ? s : "/" + s, "source": (typeof(item) == "string") ? new Files({"paths": [item]}) : item, "filter": null, "extractDirs": null});
+			} else if (((item) instanceof Array)) {
+				var inner = item;
+				if (typeof(inner[0]) != "string") {
+					throw new Error("First element of RoutePath array should be `routeUnder` (a string).");
+				};
+				if (!(((inner[1]) instanceof Router) || ((inner[1]) instanceof Stone) || typeof(inner[1]) == "string")) {
+					throw new Error("Second element of RoutePath array should be a Stone or Router.");
+				};
+				var tmp;
+				switch (inner.length) {
+					case 2:
+						var s1 = inner[0];
+						var str1 = (s1.length > 1 && HxOverrides.cca(s1, 0) == 47) ? s1.substring(1) : s1;
+						if (str1.length > 0) {
+							str1 = Path.posix.normalize(str1);
+							str1 = StringTools.replace(str1, "\\", "/");
+						};
+						s1 = str1;
+						var src = inner[1];
+						tmp = {"routeUnder": (HxOverrides.cca(s1, 0) == 47) ? s1 : "/" + s1, "source": (typeof(src) == "string") ? new Files({"paths": [src]}) : src, "filter": null, "extractDirs": null};
+						break
+					case 3:
+						var s2 = inner[0];
+						var str2 = (s2.length > 1 && HxOverrides.cca(s2, 0) == 47) ? s2.substring(1) : s2;
+						if (str2.length > 0) {
+							str2 = Path.posix.normalize(str2);
+							str2 = StringTools.replace(str2, "\\", "/");
+						};
+						s2 = str2;
+						var tmp1 = (HxOverrides.cca(s2, 0) == 47) ? s2 : "/" + s2;
+						var src1 = inner[1];
+						var tmp2 = (typeof(src1) == "string") ? new Files({"paths": [src1]}) : src1;
+						if (!(typeof(inner[2]) == "string" || inner[2] instanceof Minimatch)) {
+							throw new Error("Third" + " element of RoutePath array should be a glob pattern (string or `minimatch` object)");
+						};
+						tmp = {"routeUnder": tmp1, "source": tmp2, "filter": MinimatchType_Fields_.makeMinimatch(inner[2]), "extractDirs": null};
+						break
+					case 4:
+						var s3 = inner[0];
+						var str3 = (s3.length > 1 && HxOverrides.cca(s3, 0) == 47) ? s3.substring(1) : s3;
+						if (str3.length > 0) {
+							str3 = Path.posix.normalize(str3);
+							str3 = StringTools.replace(str3, "\\", "/");
+						};
+						s3 = str3;
+						var tmp3 = (HxOverrides.cca(s3, 0) == 47) ? s3 : "/" + s3;
+						var src2 = inner[1];
+						var tmp4 = (typeof(src2) == "string") ? new Files({"paths": [src2]}) : src2;
+						if (!(typeof(inner[2]) == "string" || inner[2] instanceof Minimatch)) {
+							throw new Error("Third" + " element of RoutePath array should be a glob pattern (string or `minimatch` object)");
+						};
+						var tmp5 = MinimatchType_Fields_.makeMinimatch(inner[2]);
+						if (!(typeof(inner[3]) == "string" || inner[3] instanceof Minimatch)) {
+							throw new Error("Fourth" + " element of RoutePath array should be a glob pattern (string or `minimatch` object)");
+						};
+						tmp = {"routeUnder": tmp3, "source": tmp4, "filter": tmp5, "extractDirs": MinimatchType_Fields_.makeMinimatch(inner[3])};
+						break
+					default:
+					throw new Error("Invalid array for a RoutePath element.");
+					
+				};
+				_g.push(tmp);
+			} else {
+				throw new Error("Unexpected RoutePath element.");
 			};
-			if (item.length > 3) {
-				throw new Error("RoutePath element should have at most 3 entries `[serveId, route, filter]`.");
-			};
-			var s = item[0];
-			var str = (s.length > 1 && HxOverrides.cca(s, 0) == 47) ? s.substring(1) : s;
-			if (str.length > 0) {
-				str = Path.posix.normalize(str);
-				str = StringTools.replace(str, "\\", "/");
-			};
-			s = str;
-			var tmp = (HxOverrides.cca(s, 0) == 47) ? s : "/" + s;
-			var _g3 = item.slice(1);
-			_g.push({"routeUnder": tmp, "route": (_g3.length == 1) ? (((item[1]) instanceof Route)) ? item[1] : RouteType_Fields_.makeRoute([_g3]) : RouteType_Fields_.makeRoute([_g3])});
 		};
 		return _g;
 	}

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

@@ -1,7 +1,9 @@
 import {RouteResult} from "./RouteResult"
-import {Route} from "./Route"
 import {RoutePathType} from "../magic/RoutePathType"
+import {MinimatchType} from "../magic/MinimatchType"
+import {AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
+import Minimatch from "minimatch"
 
 export declare class Router {
 	constructor(routes?: null | RoutePathType)
@@ -9,25 +11,30 @@ export declare class Router {
 	route(r: RoutePathType): void
 	
 	/**
-	* Find data sources routed under `id`. By default only single result is returned if `id`
-	* is not a directory, all results otherwise. This can be overriden by providing a second argument.
+	* Find data sources routed under `pattern`.
+	* @param pattern A glob pattern to search for.
 	*/
-	find(id: string, firstOnly?: null | boolean): Promise<RouteResult[]>
+	get(pattern?: MinimatchType): Promise<RouteResult[]>
 	
 	/**
-	* Get combined hash of all sources that would be found under supplied id.
+	* Get combined hash of all sources that fit the `pattern`.
 	*/
-	getHash(id: string, firstOnly?: null | boolean): Promise<SourceHash>
-	getHashOfEverything(): Promise<SourceHash>
+	getHash(pattern?: MinimatchType): Promise<SourceHash>
 	
 	/**
-	* Save files filtered by `searchId` into provided `saveInto` folder.
+	* Save files filtered by `pattern` into provided `saveInto` folder.
 	*/
-	saveInto(searchId: string, saveInto: string, clearFirst?: boolean): Promise<any>
-	listContents(search?: string): Promise<string>
+	saveInto(pattern: MinimatchType, saveInto: string, clearFirst?: boolean): Promise<any>
+	listContents(pattern?: MinimatchType): Promise<string>
+	protected allFromRoute(route: RoutePath): Promise<RouteResult[]>
+	protected getServeId(path: string, route: RoutePath): string
 }
 
 export type RoutePath = {
-	route: Route, 
-	routeUnder: string
+	extractDirs: Minimatch, 
+	filter: Minimatch, 
+	routeUnder: string, 
+	source: RouterSource
 }
+
+export type RouterSource = AnyStone | Router