whet 0.0.15 → 0.0.18

package/bin/pino_pretty/PrettyOptions.d.ts

@@ -0,0 +1,98 @@
+
+export type PrettyOptions = {
+	/**
+	Opens the file with the 'a' flag.
+	*/
+	append?: null | boolean, 
+	/**
+	If set to true, will add color information to the formatted output message.
+	*/
+	colorize?: null | boolean, 
+	/**
+	Appends carriage return and line feed, instead of just a line feed, to the formatted log line.
+	*/
+	crlf?: null | boolean, 
+	/**
+	Provides the ability to add a custom prettify function for specific log properties.
+	`customPrettifiers` is an object, where keys are log properties that will be prettified
+	and value is the prettify function itself.
+	For example, if a log line contains a query property, you can specify a prettifier for it:
+	*/
+	customPrettifiers?: null | {
+	}, 
+	/**
+	The file, file descriptor, or stream to write to.  Defaults to 1 (stdout).
+	*/
+	destination?: null | any, 
+	/**
+	Define the log keys that are associated with error like objects.
+	*/
+	errorLikeObjectKeys?: null | string[], 
+	/**
+	When formatting an error object, display this list of properties.
+	The list should be a comma separated list of properties.
+	*/
+	errorProps?: null | string, 
+	/**
+	Hide objects from output (but not error object).
+	*/
+	hideObject?: null | boolean, 
+	/**
+	Ignore one or several keys.
+	Will be overridden by the option include if include is presented.
+	*/
+	ignore?: null | string, 
+	/**
+	Include one or several keys.
+	*/
+	include?: null | string, 
+	/**
+	If set to true, it will print the name of the log level as the first field in the log line.
+	*/
+	levelFirst?: null | boolean, 
+	/**
+	Define the key that contains the level of the log.
+	*/
+	levelKey?: null | string, 
+	/**
+	Output the log level using the specified label.
+	*/
+	levelLabel?: null | string, 
+	/**
+	Format output of message, e.g. {level} - {pid} will output message: INFO - 1123
+	*/
+	messageFormat?: null | any, 
+	/**
+	The key in the JSON object to use as the highlighted message.
+	*/
+	messageKey?: null | string, 
+	/**
+	The minimum log level to include in the output.
+	*/
+	minimumLevel?: null | any, 
+	/**
+	Ensure directory for destination file exists.
+	*/
+	mkdir?: null | boolean, 
+	/**
+	Print each log message on a single line (errors will still be multi-line).
+	*/
+	singleLine?: null | boolean, 
+	/**
+	Makes messaging synchronous.
+	*/
+	sync?: null | boolean, 
+	/**
+	The key in the JSON object to use for timestamp display.
+	*/
+	timestampKey?: null | string, 
+	/**
+	Translate the epoch time value into a human readable date and time string. This flag also can set the format
+	string to apply when translating the date to human readable format. For a list of available pattern letters
+	see the {@link https://www.npmjs.com/package/dateformat|dateformat documentation}.
+	- The default format is `yyyy-mm-dd HH:MM:ss.l o` in UTC.
+	- Requires a `SYS:` prefix to translate time to the local system's timezone. Use the shortcut `SYS:standard`
+	to translate time to `yyyy-mm-dd HH:MM:ss.l o` in system timezone.
+	*/
+	translateTime?: null | any
+}

package/bin/pino_pretty/default_/MessageFormatFunc.d.ts

@@ -0,0 +1,3 @@
+
+export type MessageFormatFunc = ((log: {
+}, messageKey: string, levelLabel: string) => string)

package/bin/whet/Log.d.ts

@@ -7,6 +7,7 @@ export declare class Log {
 	static error(...args: any[]): void
 	static fatal(...args: any[]): void
 	static logLevel: number
+	static stream: IWritable
 	protected static log(level: number, ...args: any[]): void
 	protected static replacer(key: any, val: any): any
 }

package/bin/whet/Log.js

@@ -50,12 +50,12 @@ class Log {
 					};
 				};
 			};
-			process.stdout.write(JSON.stringify(out, Log.replacer) + "\n");
+			Log.stream.write(JSON.stringify(out, Log.replacer) + "\n");
 		};
 	}
 	static replacer(key, val) {
 		if (((val) instanceof Error)) {
-			return val.stack;
+			return {"type": val.name, "message": val.message, "stack": val.stack};
 		};
 		if (val != null && typeof(val.toString) == "function" && val.toString != Object.prototype.toString) {
 			return val.toString();
@@ -72,6 +72,7 @@ class Log {
 
 
 Log.logLevel = 30
+Log.stream = process.stdout
 export const LogLevel = Register.global("$hxClasses")["whet._Log.LogLevel"] = 
 class LogLevel {
 	static fromString(s) {

package/bin/whet/Stone.js

@@ -161,6 +161,7 @@ class Stone extends Register.inherits() {
 	* @param err Any error that might have happened during `generateSource`.
 	*/
 	handleError(err) {
+		Log.log(50, ...["Error while generating.", {"stone": this, "err": err}]);
 		return Promise.reject(err);
 	}
 	

package/bin/whet/Whet.d.ts

@@ -2,3 +2,4 @@ import {Command} from "commander"
 
 export const program: Command
 export const main: () => void
+export const executeCommand: (cmd: string[]) => Promise<Command>

package/bin/whet/Whet.js

@@ -1,8 +1,9 @@
 import {Project} from "./Project.js"
 import {LogLevel, Log} from "./Log.js"
 import * as Url from "url"
+import * as PinoPretty from "pino-pretty"
 import {Register} from "../genes/Register.js"
-import {Command} from "commander"
+import {Command, CommanderError} from "commander"
 import {Std} from "../Std.js"
 
 const $global = Register.$global
@@ -10,7 +11,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.15", "-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.18", "-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").option("--no-pretty", "disable pretty logging").exitOverride();
 		Whet_Fields_.program.parse();
 		var options = Whet_Fields_.program.opts();
 		if (options.logLevel != null) {
@@ -24,6 +25,9 @@ class Whet_Fields_ {
 				Log.logLevel = n;
 			};
 		};
+		if (options.pretty) {
+			Log.stream = PinoPretty["default"]();
+		};
 		global.setImmediate(Whet_Fields_.init, options);
 	}
 	static init(options) {
@@ -41,7 +45,10 @@ class Whet_Fields_ {
 				if (((e) instanceof Error)) {
 					Log.log(50, ...[e.stack]);
 				};
-				return Whet_Fields_.program.help();
+				try {
+					Whet_Fields_.program.help();
+				}catch (_g) {
+				};
 			});
 		};
 	}
@@ -87,12 +94,21 @@ class Whet_Fields_ {
 			Log.log(10, ...["Executing command.", {"commandArgs": c}]);
 			Whet_Fields_.program.parseAsync(c, {"from": "user"}).then(function (_) {
 				nextCommand();
+			})["catch"](function (err) {
+				if (((err) instanceof CommanderError) && err.code == "commander.help") {
+					return;
+				};
+				Log.log(50, ...["Error while executing command.", {"error": err}]);
 			});
 		};
 		initProm.then(function (_) {
 			nextCommand();
 		});
 	}
+	static executeCommand(cmd) {
+		Log.log(10, ...["Executing command.", {"command": cmd}]);
+		return Whet_Fields_.program.parseAsync(cmd, {"from": "user"});
+	}
 	static getCommands(args) {
 		var commands = [];
 		var from = 0;
@@ -119,3 +135,4 @@ class Whet_Fields_ {
 Whet_Fields_.program = new Command("whet")
 export const program = Whet_Fields_.program
 export const main = Whet_Fields_.main
+export const executeCommand = Whet_Fields_.executeCommand

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