whet 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Peter Achberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# Whet
+
+A NodeJS-based tool for managing things every project needs, such as configuration, build scripts, assets, etc., using a flexible everything-is-an-asset approach, with configurable caching.
+
+## Project Files
+
+Project files define a project, its [stones](#Stones). Their content defines what [commands](#Commands) are available.
+
+## Stones
+
+Stones (named after _whetstone_) are individual building blocks of a project.
+
+They represent a single logical asset (can be multiple files) or functionality (e.g. a dev web server). Stones can use other stones (via routes), to achieve their objective, forming a dependency tree. E.g. a css file could be made by minifying a file generated from scss source, and each step could be individually cached.
+
+### Stones Configuration
+
+Stones try to keep all their state in a `config` object. Each stone requires it to be supplied. The `config` object should be designed for scripting, i.e. allow dynamic types as long as they make sense.
+
+Reading and applying the configuration should be limited to generating resources/hashes from the stone. Invalid configuration therefore won't crash the project initialization until it's being used. This is just a guideline and not a requirement, and stones might validate the configuration immediately where it makes sense.
+
+<!-- TODO: Implement, and then mention `project.getHash()` as a way to verify the whole project. -->
+
+Some stones might provide helper methods to modify the configuration after it was passed in. Such methods might modify the `config` object, e.g. turning a single entry into array of them.
+
+### Hashes
+
+...
+
+### Commands
+
+...
+
+## Routes And Routers
+
+...
+
+## Core Concepts
+
+Project files should have no side effects, unless some of their commands are executed. They only process the active configuration, initializing the available commands.
+
+<!-- TODO: document configuration handlers -->
+
+All paths are in stored as absolute (starting with `/`), but are actually relative to root project directory. Path that is a directory ends with a `/`, otherwise it's considered a file. That means:
+
+- `/assets/` is a **directory** called `assets` that's in the project root.
+- `assets/` is a **directory** called `assets` that's relative to the structure within the project (routing/stones).
+- `/assets` is a **file** called `assets` in the project root.

package/bin/HxOverrides.d.ts

@@ -0,0 +1,8 @@
+
+export declare class HxOverrides {
+	protected static dateStr(date: Date): string
+	protected static cca(s: string, index: number): null | number
+	protected static substr(s: string, pos: number, len?: null | number): string
+	protected static remove<T>(a: T[], obj: T): boolean
+	protected static now(): number
+}

package/bin/HxOverrides.js

@@ -0,0 +1,54 @@
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+export const HxOverrides = Register.global("$hxClasses")["HxOverrides"] = 
+class HxOverrides {
+	static dateStr(date) {
+		var m = date.getMonth() + 1;
+		var d = date.getDate();
+		var h = date.getHours();
+		var mi = date.getMinutes();
+		var s = date.getSeconds();
+		return date.getFullYear() + "-" + ((m < 10) ? "0" + m : "" + m) + "-" + ((d < 10) ? "0" + d : "" + d) + " " + ((h < 10) ? "0" + h : "" + h) + ":" + ((mi < 10) ? "0" + mi : "" + mi) + ":" + ((s < 10) ? "0" + s : "" + s);
+	}
+	static cca(s, index) {
+		var x = s.charCodeAt(index);
+		if (x != x) {
+			return undefined;
+		};
+		return x;
+	}
+	static substr(s, pos, len) {
+		if (len == null) {
+			len = s.length;
+		} else if (len < 0) {
+			if (pos == 0) {
+				len = s.length + len;
+			} else {
+				return "";
+			};
+		};
+		return s.substr(pos, len);
+	}
+	static remove(a, obj) {
+		var i = a.indexOf(obj);
+		if (i == -1) {
+			return false;
+		};
+		a.splice(i, 1);
+		return true;
+	}
+	static now() {
+		return Date.now();
+	}
+	static get __name__() {
+		return "HxOverrides"
+	}
+	get __class__() {
+		return HxOverrides
+	}
+}
+
+
+;((typeof(performance) != "undefined") ? typeof(performance.now) == "function" : false) ? HxOverrides.now = performance.now.bind(performance) : null

package/bin/Lambda.d.ts

@@ -0,0 +1,86 @@
+import {List} from "./haxe/ds/List"
+import {Iterable} from "./StdTypes"
+
+/**
+The `Lambda` class is a collection of methods to support functional
+programming. It is ideally used with `using Lambda` and then acts as an
+extension to Iterable types.
+
+On static platforms, working with the Iterable structure might be slower
+than performing the operations directly on known types, such as Array and
+List.
+
+If the first argument to any of the methods is null, the result is
+unspecified.
+
+@see https://haxe.org/manual/std-Lambda.html
+*/
+export declare class Lambda {
+	
+	/**
+	Creates a List form Iterable `it`.
+	
+	If `it` is a List, this function returns a copy of it.
+	*/
+	static list<A>(it: Iterable<A>): List<A>
+	
+	/**
+	Tells if `it` contains an element for which `f` is true.
+	
+	This function returns true as soon as an element is found for which a
+	call to `f` returns true.
+	
+	If no such element is found, the result is false.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static exists<A>(it: Iterable<A>, f: ((item: A) => boolean)): boolean
+	
+	/**
+	Tells if `f` is true for all elements of `it`.
+	
+	This function returns false as soon as an element is found for which a
+	call to `f` returns false.
+	
+	If no such element is found, the result is true.
+	
+	In particular, this function always returns true if `it` is empty.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static foreach<A>(it: Iterable<A>, f: ((item: A) => boolean)): boolean
+	
+	/**
+	Functional fold on Iterable `it`, using function `f` with start argument
+	`first`.
+	
+	If `it` has no elements, the result is `first`.
+	
+	Otherwise the first element of `it` is passed to `f` alongside `first`.
+	The result of that call is then passed to `f` with the next element of
+	`it`, and so on until `it` has no more elements.
+	
+	If `it` or `f` are null, the result is unspecified.
+	*/
+	static fold<B, A>(it: Iterable<A>, f: ((item: A, result: B) => B), first: B): B
+	
+	/**
+	Returns the number of elements in `it` for which `pred` is true, or the
+	total number of elements in `it` if `pred` is null.
+	
+	This function traverses all elements.
+	*/
+	static count<A>(it: Iterable<A>, pred?: null | ((item: A) => boolean)): number
+	
+	/**
+	Returns the first element of `it` for which `f` is true.
+	
+	This function returns as soon as an element is found for which a call to
+	`f` returns true.
+	
+	If no such element is found, the result is null.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static find<T>(it: Iterable<T>, f: ((item: T) => boolean)): null | T
+}

package/bin/Lambda.js

@@ -0,0 +1,141 @@
+import {List} from "./haxe/ds/List.js"
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+/**
+The `Lambda` class is a collection of methods to support functional
+programming. It is ideally used with `using Lambda` and then acts as an
+extension to Iterable types.
+
+On static platforms, working with the Iterable structure might be slower
+than performing the operations directly on known types, such as Array and
+List.
+
+If the first argument to any of the methods is null, the result is
+unspecified.
+
+@see https://haxe.org/manual/std-Lambda.html
+*/
+export const Lambda = Register.global("$hxClasses")["Lambda"] = 
+class Lambda {
+	
+	/**
+	Creates a List form Iterable `it`.
+	
+	If `it` is a List, this function returns a copy of it.
+	*/
+	static list(it) {
+		var l = new List();
+		var i = Register.iter(it);
+		while (i.hasNext()) l.add(i.next());
+		return l;
+	}
+	
+	/**
+	Tells if `it` contains an element for which `f` is true.
+	
+	This function returns true as soon as an element is found for which a
+	call to `f` returns true.
+	
+	If no such element is found, the result is false.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static exists(it, f) {
+		var x = Register.iter(it);
+		while (x.hasNext()) if (f(x.next())) {
+			return true;
+		};
+		return false;
+	}
+	
+	/**
+	Tells if `f` is true for all elements of `it`.
+	
+	This function returns false as soon as an element is found for which a
+	call to `f` returns false.
+	
+	If no such element is found, the result is true.
+	
+	In particular, this function always returns true if `it` is empty.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static foreach(it, f) {
+		var x = Register.iter(it);
+		while (x.hasNext()) if (!f(x.next())) {
+			return false;
+		};
+		return true;
+	}
+	
+	/**
+	Functional fold on Iterable `it`, using function `f` with start argument
+	`first`.
+	
+	If `it` has no elements, the result is `first`.
+	
+	Otherwise the first element of `it` is passed to `f` alongside `first`.
+	The result of that call is then passed to `f` with the next element of
+	`it`, and so on until `it` has no more elements.
+	
+	If `it` or `f` are null, the result is unspecified.
+	*/
+	static fold(it, f, first) {
+		var x = Register.iter(it);
+		while (x.hasNext()) first = f(x.next(), first);
+		return first;
+	}
+	
+	/**
+	Returns the number of elements in `it` for which `pred` is true, or the
+	total number of elements in `it` if `pred` is null.
+	
+	This function traverses all elements.
+	*/
+	static count(it, pred) {
+		var n = 0;
+		if (pred == null) {
+			var _ = Register.iter(it);
+			while (_.hasNext()) {
+				_.next();
+				++n;
+			};
+		} else {
+			var x = Register.iter(it);
+			while (x.hasNext()) if (pred(x.next())) {
+				++n;
+			};
+		};
+		return n;
+	}
+	
+	/**
+	Returns the first element of `it` for which `f` is true.
+	
+	This function returns as soon as an element is found for which a call to
+	`f` returns true.
+	
+	If no such element is found, the result is null.
+	
+	If `f` is null, the result is unspecified.
+	*/
+	static find(it, f) {
+		var v = Register.iter(it);
+		while (v.hasNext()) {
+			var v1 = v.next();
+			if (f(v1)) {
+				return v1;
+			};
+		};
+		return null;
+	}
+	static get __name__() {
+		return "Lambda"
+	}
+	get __class__() {
+		return Lambda
+	}
+}
+

package/bin/Map.d.ts

@@ -0,0 +1,5 @@
+import {IMap as IMap__1} from "./haxe/Constraints"
+
+export type Map<K, V> = IMap__1<K, V>
+
+export type IMap<K, V> = IMap__1<K, V>

package/bin/Reflect.d.ts

@@ -0,0 +1,19 @@
+
+/**
+The Reflect API is a way to manipulate values dynamically through an
+abstract interface in an untyped manner. Use with care.
+
+@see https://haxe.org/manual/std-reflection.html
+*/
+export declare class Reflect {
+	
+	/**
+	Returns the fields of structure `o`.
+	
+	This method is only guaranteed to work on anonymous structures. Refer to
+	`Type.getInstanceFields` for a function supporting class instances.
+	
+	If `o` is null, the result is unspecified.
+	*/
+	static fields(o: any): string[]
+}

package/bin/Reflect.js

@@ -0,0 +1,41 @@
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+/**
+The Reflect API is a way to manipulate values dynamically through an
+abstract interface in an untyped manner. Use with care.
+
+@see https://haxe.org/manual/std-reflection.html
+*/
+export const Reflect = Register.global("$hxClasses")["Reflect"] = 
+class Reflect {
+	
+	/**
+	Returns the fields of structure `o`.
+	
+	This method is only guaranteed to work on anonymous structures. Refer to
+	`Type.getInstanceFields` for a function supporting class instances.
+	
+	If `o` is null, the result is unspecified.
+	*/
+	static fields(o) {
+		var a = [];
+		if (o != null) {
+			var hasOwnProperty = Object.prototype.hasOwnProperty;
+			for( var f in o ) {;
+			if (f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o, f)) {
+				a.push(f);
+			};
+			};
+		};
+		return a;
+	}
+	static get __name__() {
+		return "Reflect"
+	}
+	get __class__() {
+		return Reflect
+	}
+}
+

package/bin/Std.d.ts

@@ -0,0 +1,49 @@
+
+/**
+The Std class provides standard methods for manipulating basic types.
+*/
+export declare class Std {
+	
+	/**
+	Converts any value to a String.
+	
+	If `s` is of `String`, `Int`, `Float` or `Bool`, its value is returned.
+	
+	If `s` is an instance of a class and that class or one of its parent classes has
+	a `toString` method, that method is called. If no such method is present, the result
+	is unspecified.
+	
+	If `s` is an enum constructor without argument, the constructor's name is returned. If
+	arguments exists, the constructor's name followed by the String representations of
+	the arguments is returned.
+	
+	If `s` is a structure, the field names along with their values are returned. The field order
+	and the operator separating field names and values are unspecified.
+	
+	If s is null, "null" is returned.
+	*/
+	static string(s: any): string
+	
+	/**
+	Converts a `String` to an `Int`.
+	
+	Leading whitespaces are ignored.
+	
+	If `x` starts with 0x or 0X, hexadecimal notation is recognized where the following digits may
+	contain 0-9 and A-F.
+	
+	Otherwise `x` is read as decimal number with 0-9 being allowed characters. `x` may also start with
+	a - to denote a negative value.
+	
+	In decimal mode, parsing continues until an invalid character is detected, in which case the
+	result up to that point is returned. For hexadecimal notation, the effect of invalid characters
+	is unspecified.
+	
+	Leading 0s that are not part of the 0x/0X hexadecimal notation are ignored, which means octal
+	notation is not supported.
+	
+	If `x` is null, the result is unspecified.
+	If `x` cannot be parsed as integer, the result is `null`.
+	*/
+	static parseInt(x: string): null | number
+}

package/bin/Std.js

@@ -0,0 +1,96 @@
+import {Boot} from "./js/Boot.js"
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+/**
+The Std class provides standard methods for manipulating basic types.
+*/
+export const Std = Register.global("$hxClasses")["Std"] = 
+class Std {
+	
+	/**
+	Converts any value to a String.
+	
+	If `s` is of `String`, `Int`, `Float` or `Bool`, its value is returned.
+	
+	If `s` is an instance of a class and that class or one of its parent classes has
+	a `toString` method, that method is called. If no such method is present, the result
+	is unspecified.
+	
+	If `s` is an enum constructor without argument, the constructor's name is returned. If
+	arguments exists, the constructor's name followed by the String representations of
+	the arguments is returned.
+	
+	If `s` is a structure, the field names along with their values are returned. The field order
+	and the operator separating field names and values are unspecified.
+	
+	If s is null, "null" is returned.
+	*/
+	static string(s) {
+		return Boot.__string_rec(s, "");
+	}
+	
+	/**
+	Converts a `String` to an `Int`.
+	
+	Leading whitespaces are ignored.
+	
+	If `x` starts with 0x or 0X, hexadecimal notation is recognized where the following digits may
+	contain 0-9 and A-F.
+	
+	Otherwise `x` is read as decimal number with 0-9 being allowed characters. `x` may also start with
+	a - to denote a negative value.
+	
+	In decimal mode, parsing continues until an invalid character is detected, in which case the
+	result up to that point is returned. For hexadecimal notation, the effect of invalid characters
+	is unspecified.
+	
+	Leading 0s that are not part of the 0x/0X hexadecimal notation are ignored, which means octal
+	notation is not supported.
+	
+	If `x` is null, the result is unspecified.
+	If `x` cannot be parsed as integer, the result is `null`.
+	*/
+	static parseInt(x) {
+		if (x != null) {
+			var _g = 0;
+			var _g1 = x.length;
+			while (_g < _g1) {
+				var i = _g++;
+				var c = x.charCodeAt(i);
+				if (c <= 8 || c >= 14 && c != 32 && c != 45) {
+					var nc = x.charCodeAt(i + 1);
+					var v = parseInt(x, (nc == 120 || nc == 88) ? 16 : 10);
+					if ((isNaN)(v)) {
+						return null;
+					} else {
+						return v;
+					};
+				};
+			};
+		};
+		return null;
+	}
+	static get __name__() {
+		return "Std"
+	}
+	get __class__() {
+		return Std
+	}
+}
+
+
+;{
+	String.prototype.__class__ = String;
+	String.__name__ = "String";
+	Array.__name__ = "Array";
+	Date.prototype.__class__ = Date;
+	Date.__name__ = "Date";
+	var Int = { };;
+	var Dynamic = { };;
+	var Float = Number;
+	var Bool = Boolean;
+	var Class = { };;
+	var Enum = { };;
+}

package/bin/StdTypes.d.ts

@@ -0,0 +1,57 @@
+
+/**
+An `Iterator` is a structure that permits iteration over elements of type `T`.
+
+Any class with matching `hasNext()` and `next()` fields is considered an `Iterator`
+and can then be used e.g. in `for`-loops. This makes it easy to implement
+custom iterators.
+
+@see https://haxe.org/manual/lf-iterators.html
+*/
+export type Iterator<T> = {
+	/**
+	Returns `false` if the iteration is complete, `true` otherwise.
+	
+	Usually iteration is considered to be complete if all elements of the
+	underlying data structure were handled through calls to `next()`. However,
+	in custom iterators any logic may be used to determine the completion
+	state.
+	*/
+	hasNext: () => boolean, 
+	/**
+	Returns the current item of the `Iterator` and advances to the next one.
+	
+	This method is not required to check `hasNext()` first. A call to this
+	method while `hasNext()` is `false` yields unspecified behavior.
+	
+	On the other hand, iterators should not require a call to `hasNext()`
+	before the first call to `next()` if an element is available.
+	*/
+	next: () => T
+}
+
+/**
+An `Iterable` is a data structure which has an `iterator()` method.
+See `Lambda` for generic functions on iterable structures.
+
+@see https://haxe.org/manual/lf-iterators.html
+*/
+export type Iterable<T> = {
+	iterator: () => Iterator<T>
+}
+
+/**
+A `KeyValueIterator` is an `Iterator` that has a key and a value.
+*/
+export type KeyValueIterator<K, V> = Iterator<{
+	key: K, 
+	value: V
+}>
+
+/**
+A `KeyValueIterable` is a data structure which has a `keyValueIterator()`
+method to iterate over key-value-pairs.
+*/
+export type KeyValueIterable<K, V> = {
+	keyValueIterator: () => KeyValueIterator<K, V>
+}

package/bin/StringTools.d.ts

@@ -0,0 +1,23 @@
+
+/**
+This class provides advanced methods on Strings. It is ideally used with
+`using StringTools` and then acts as an [extension](https://haxe.org/manual/lf-static-extension.html)
+to the `String` class.
+
+If the first argument to any of the methods is null, the result is
+unspecified.
+*/
+export declare class StringTools {
+	
+	/**
+	Replace all occurrences of the String `sub` in the String `s` by the
+	String `by`.
+	
+	If `sub` is the empty String `""`, `by` is inserted after each character
+	of `s` except the last one. If `by` is also the empty String `""`, `s`
+	remains unchanged.
+	
+	If `sub` or `by` are null, the result is unspecified.
+	*/
+	static replace(s: string, sub: string, by: string): string
+}

package/bin/StringTools.js

@@ -0,0 +1,36 @@
+import {Register} from "./genes/Register.js"
+
+const $global = Register.$global
+
+/**
+This class provides advanced methods on Strings. It is ideally used with
+`using StringTools` and then acts as an [extension](https://haxe.org/manual/lf-static-extension.html)
+to the `String` class.
+
+If the first argument to any of the methods is null, the result is
+unspecified.
+*/
+export const StringTools = Register.global("$hxClasses")["StringTools"] = 
+class StringTools {
+	
+	/**
+	Replace all occurrences of the String `sub` in the String `s` by the
+	String `by`.
+	
+	If `sub` is the empty String `""`, `by` is inserted after each character
+	of `s` except the last one. If `by` is also the empty String `""`, `s`
+	remains unchanged.
+	
+	If `sub` or `by` are null, the result is unspecified.
+	*/
+	static replace(s, sub, by) {
+		return s.split(sub).join(by);
+	}
+	static get __name__() {
+		return "StringTools"
+	}
+	get __class__() {
+		return StringTools
+	}
+}
+