whet 0.0.1

package/bin/js/node/stream/Readable.d.ts

@@ -0,0 +1,41 @@
+
+/**
+Options for `Readable` private constructor.
+For stream implementors only, see node.js API documentation
+*/
+export type ReadableNewOptions = {
+	/**
+	Whether this stream should automatically call `.destroy()` on itself after ending.
+	Default: `false`.
+	*/
+	autoDestroy?: null | boolean, 
+	/**
+	Implementation for the `stream._destroy()` method.
+	*/
+	destroy?: null | ((err: null | Error, callback: ((arg0: null | Error) => void)) => void), 
+	/**
+	Whether or not the stream should emit `'close'` after it has been destroyed.
+	Default: `true`.
+	*/
+	emitClose?: null | boolean, 
+	/**
+	If specified, then buffers will be decoded to strings using the specified encoding.
+	Default: `null`.
+	*/
+	encoding?: null | string, 
+	/**
+	The maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource.
+	Default: `16384` (16kb), or `16` for `objectMode` streams.
+	*/
+	highWaterMark?: null | number, 
+	/**
+	Whether this stream should behave as a stream of objects.
+	Meaning that `stream.read(n)` returns a single value instead of a `Buffer` of size `n`.
+	Default: `false`.
+	*/
+	objectMode?: null | boolean, 
+	/**
+	Implementation for the `stream._read()` method.
+	*/
+	read?: null | ((size: number) => void)
+}

package/bin/js/node/stream/Transform.d.ts

@@ -0,0 +1,92 @@
+import {Chunk} from "./Writable"
+
+/**
+@see https://nodejs.org/api/stream.html#stream_new_stream_transform_options
+*/
+export type TransformNewOptions = {
+	/**
+	If set to `false`, then the stream will automatically end the writable side when the readable side ends. Default: `true`.
+	*/
+	allowHalfOpen?: null | boolean, 
+	/**
+	Whether this stream should automatically call `.destroy()` on itself after ending.
+	Default: `false`.
+	*/
+	autoDestroy?: null | boolean, 
+	/**
+	`decodeStrings` <boolean> Whether to encode `string`s passed to stream.write() to `Buffer`s (with the encoding specified in the stream.write() call) before passing them to stream._write().
+	Other types of data are not converted (i.e. `Buffer`s are not decoded into `string`s). Setting to false will prevent strings from being converted.
+	Default: `true`.
+	*/
+	decodeStrings?: null | boolean, 
+	/**
+	`defaultEncoding` <string> The default encoding that is used when no encoding is specified as an argument to stream.write().
+	Default: `'utf8'`.
+	*/
+	defaultEncoding?: null | string, 
+	/**
+	Implementation for the `stream._destroy()` method.
+	*/
+	destroy?: null | ((err: null | Error, callback: ((arg0: null | Error) => void)) => void), 
+	/**
+	Whether or not the stream should emit `'close'` after it has been destroyed.
+	Default: `true`.
+	*/
+	emitClose?: null | boolean, 
+	/**
+	If specified, then buffers will be decoded to strings using the specified encoding.
+	Default: `null`.
+	*/
+	encoding?: null | string, 
+	/**
+	`final` <Function> Implementation for the stream._final() method.
+	*/
+	final_?: null | ((error: null | Error) => void), 
+	/**
+	Implementation for the `stream._flush()` method.
+	*/
+	flush?: null | ((arg0: null | Error) => void), 
+	/**
+	The maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource.
+	Default: `16384` (16kb), or `16` for `objectMode` streams.
+	*/
+	highWaterMark?: null | number, 
+	/**
+	Whether this stream should behave as a stream of objects.
+	Meaning that `stream.read(n)` returns a single value instead of a `Buffer` of size `n`.
+	Default: `false`.
+	*/
+	objectMode?: null | boolean, 
+	/**
+	Implementation for the `stream._read()` method.
+	*/
+	read?: null | ((size: number) => void), 
+	/**
+	Sets `highWaterMark` for the readable side of the stream. Has no effect if `highWaterMark` is provided.
+	*/
+	readableHighWaterMark?: null | number, 
+	/**
+	Sets `objectMode` for readable side of the stream. Has no effect if `objectMode` is `true`. Default: `false`.
+	*/
+	readableObjectMode?: null | boolean, 
+	/**
+	Implementation for the `stream._transform()` method.
+	*/
+	transform?: null | ((chunk: any, encoding: string, callback: ((error: null | Error, data: any) => void)) => void), 
+	/**
+	Sets `highWaterMark` for the writable side of the stream. Has no effect if `highWaterMark` is provided.
+	*/
+	writableHighWaterMark?: null | number, 
+	/**
+	Sets `objectMode` for writable side of the stream. Has no effect if `objectMode` is `true`. Default: `false`.
+	*/
+	writableObjectMode?: null | boolean, 
+	/**
+	`write` <Function> Implementation for the stream._write() method.
+	*/
+	write?: null | ((chunk: any, encoding: string, callback: ((arg0: null | Error) => void)) => void), 
+	/**
+	`writev` <Function> Implementation for the stream._writev() method.
+	*/
+	writev?: null | ((chunks: Chunk[], callback: ((arg0: null | Error) => void)) => void)
+}

package/bin/js/node/stream/Writable.d.ts

@@ -0,0 +1,57 @@
+
+/**
+@see https://nodejs.org/api/stream.html#stream_constructor_new_stream_writable_options
+*/
+export type WritableNewOptions = {
+	/**
+	`autoDestroy` <boolean> Whether this stream should automatically call .destroy() on itself after ending. Default: false.
+	*/
+	autoDestroy?: null | boolean, 
+	/**
+	`decodeStrings` <boolean> Whether to encode `string`s passed to stream.write() to `Buffer`s (with the encoding specified in the stream.write() call) before passing them to stream._write().
+	Other types of data are not converted (i.e. `Buffer`s are not decoded into `string`s). Setting to false will prevent strings from being converted.
+	Default: `true`.
+	*/
+	decodeStrings?: null | boolean, 
+	/**
+	`defaultEncoding` <string> The default encoding that is used when no encoding is specified as an argument to stream.write().
+	Default: `'utf8'`.
+	*/
+	defaultEncoding?: null | string, 
+	/**
+	`destroy` <Function> Implementation for the stream._destroy() method.
+	*/
+	destroy?: null | ((error: null | Error, callback: ((arg0: null | Error) => void)) => void), 
+	/**
+	`emitClose` <boolean> Whether or not the stream should emit `'close'` after it has been destroyed.
+	Default: `true`.
+	*/
+	emitClose?: null | boolean, 
+	/**
+	`final` <Function> Implementation for the stream._final() method.
+	*/
+	final_?: null | ((error: null | Error) => void), 
+	/**
+	`highWaterMark` <number> Buffer level when stream.write() starts returning `false`. Default: `16384` (16kb), or 16 for `objectMode` streams.
+	*/
+	highWaterMark?: null | number, 
+	/**
+	`objectMode` <boolean> Whether or not the stream.write(anyObj) is a valid operation. When set,
+	it becomes possible to write JavaScript values other than string, `Buffer` or `Uint8Array` if supported by the stream implementation.
+	Default: `false`.
+	*/
+	objectMode?: null | boolean, 
+	/**
+	`write` <Function> Implementation for the stream._write() method.
+	*/
+	write?: null | ((chunk: any, encoding: string, callback: ((arg0: null | Error) => void)) => void), 
+	/**
+	`writev` <Function> Implementation for the stream._writev() method.
+	*/
+	writev?: null | ((chunks: Chunk[], callback: ((arg0: null | Error) => void)) => void)
+}
+
+export type Chunk = {
+	chunk: any, 
+	encoding: string
+}

package/bin/js/node/tls/SecureContext.d.ts

@@ -0,0 +1,74 @@
+import {Buffer} from "buffer"
+
+export type SecureContextOptions = {
+	/**
+	trusted certificates in PEM format.
+	If this is omitted several well known "root" CAs will be used, like VeriSign.
+	These are used to authorize connections.
+	*/
+	ca?: null | string | Buffer[], 
+	/**
+	certificate key of the server in PEM format.
+	*/
+	cert?: null | string | Buffer, 
+	/**
+	ciphers to use or exclude.
+	
+	To mitigate BEAST attacks it is recommended that you use this option in conjunction with the `honorCipherOrder`
+	option described below to prioritize the non-CBC cipher.
+	
+	Defaults to AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH.
+	
+	Consult the OpenSSL cipher list format documentation for details on the format.
+	ECDH (Elliptic Curve Diffie-Hellman) ciphers are not yet supported.
+	*/
+	ciphers?: null | string, 
+	/**
+	PEM encoded CRLs (Certificate Revocation List)
+	*/
+	crl?: null | string | string[], 
+	/**
+	Diffie Hellman parameters, required for Perfect Forward Secrecy.
+	
+	Use openssl dhparam to create it. Its key length should be greater than or equal to 1024 bits,
+	otherwise it throws an error. It is strongly recommended to use 2048 bits or more for stronger security.
+	If omitted or invalid, it is silently discarded and DHE ciphers won't be available.
+	*/
+	dhparam?: null | string | Buffer, 
+	/**
+	named curve to use for ECDH key agreement or false to disable ECDH.
+	
+	Defaults to prime256v1 (NIST P-256). Use `Crypto.getCurves` to obtain a list of available curve names.
+	On recent releases, openssl ecparam -list_curves will also display the name and description
+	of each available elliptic curve.
+	*/
+	ecdhCurve?: null | string, 
+	/**
+	When choosing a cipher, use the server's preferences instead of the client preferences.
+	Default: true.
+	*/
+	honorCipherOrder?: null | boolean, 
+	/**
+	private key of the server in PEM format.
+	*/
+	key?: null | string | Buffer, 
+	/**
+	passphrase for the private key or pfx.
+	*/
+	passphrase?: null | string, 
+	/**
+	private key, certificate and CA certs of the server in PFX or PKCS12 format.
+	*/
+	pfx?: null | string | Buffer, 
+	/**
+	The SSL method to use, e.g. SSLv3_method to force SSL version 3.
+	The possible values depend on your installation of OpenSSL and are defined in the constant SSL_METHODS.
+	*/
+	secureProtocol?: null | string, 
+	/**
+	opaque identifier for session resumption.
+	If `requestCert` is true, the default is MD5 hash value generated from command-line.
+	Otherwise, the default is not provided.
+	*/
+	sessionIdContext?: null | string
+}

package/bin/js/node/tls/TLSSocket.d.ts

@@ -0,0 +1,47 @@
+import {Server} from "net"
+import {Buffer} from "buffer"
+
+export type TLSSocketOptions = {
+	/**
+	possible NPN protocols. (Protocols should be ordered by their priority).
+	*/
+	NPNProtocols?: null | string[] | Buffer, 
+	/**
+	A function that will be called if client supports SNI TLS extension.
+	Two argument will be passed to it: `servername`, and `cb`.
+	SNICallback should invoke `cb(null, ctx)`, where `ctx` is a SecureContext instance.
+	(You can use tls.createSecureContext(...) to get proper `SecureContext`).
+	If `SNICallback` wasn't provided - default callback with high-level API will be used.
+	*/
+	SNICallback?: null | ((servername: string, cb: ((arg0: Error) => SecureContext)) => void), 
+	/**
+	If true - TLS socket will be instantiated in server-mode
+	*/
+	isServer?: null | boolean, 
+	/**
+	If true the server will reject any connection which is not authorized with the list of supplied CAs.
+	This option only has an effect if `requestCert` is true.
+	Default: false.
+	*/
+	rejectUnauthorized?: null | boolean, 
+	/**
+	If true the server will request a certificate from clients that connect
+	and attempt to verify that certificate.
+	Default: false.
+	*/
+	requestCert?: null | boolean, 
+	/**
+	If true - OCSP status request extension would be added to client hello,
+	and OCSPResponse event will be emitted on socket before establishing secure communication
+	*/
+	requestOCSP?: null | boolean, 
+	/**
+	An optional TLS context object from `Tls.createSecureContext`
+	*/
+	secureContext?: null | SecureContext, 
+	server?: null | Server, 
+	/**
+	A Buffer instance, containing TLS session.
+	*/
+	session?: any
+}

package/bin/ts/Undefined.d.ts

@@ -0,0 +1,5 @@
+
+/**
+`Undefined` corresponds to `void` in TypeScript; in haxe `Void` cannot be used as a field type (only function return) so we must use `Any` instead. This alias serves as documentation that the type is `void` and therefore value is `undefined`
+*/
+export type Undefined = any

package/bin/whet/Log.d.ts

@@ -0,0 +1,16 @@
+
+export declare class Log {
+	static trace(...args: any[]): void
+	static debug(...args: any[]): void
+	static info(...args: any[]): void
+	static warn(...args: any[]): void
+	static error(...args: any[]): void
+	static fatal(...args: any[]): void
+	static logLevel: number
+	protected static log(level: number, ...args: any[]): void
+	protected static replacer(key: any, val: any): any
+}
+
+export declare class LogLevel {
+	static fromString(s: string): null | number
+}

package/bin/whet/Log.js

@@ -0,0 +1,106 @@
+import {Register} from "../genes/Register.js"
+import {Reflect as Reflect__1} from "../Reflect.js"
+
+const $global = Register.$global
+
+export const Log = Register.global("$hxClasses")["whet.Log"] = 
+class Log {
+	static trace(...args) {
+		Log.log(10, ...args);
+	}
+	static debug(...args) {
+		Log.log(20, ...args);
+	}
+	static info(...args) {
+		Log.log(30, ...args);
+	}
+	static warn(...args) {
+		Log.log(40, ...args);
+	}
+	static error(...args) {
+		Log.log(50, ...args);
+	}
+	static fatal(...args) {
+		Log.log(60, ...args);
+	}
+	static log(level, ...args) {
+		if (level >= Log.logLevel) {
+			var out = {"level": level, "time": Date.now(), "msg": null};
+			var _g_current = 0;
+			while (_g_current < args.length) {
+				var arg = args[_g_current++];
+				if (arg == null) {
+					continue;
+				};
+				if (typeof(arg) == "string") {
+					if (out["msg"] == null) {
+						out["msg"] = arg;
+					} else if (typeof(out["msg"]) == "string") {
+						out["msg"] = [out["msg"], arg];
+					} else {
+						out["msg"].push(arg);
+					};
+				} else {
+					var obj = arg;
+					var _g1_keys = Reflect__1.fields(obj);
+					var _g1_index = 0;
+					while (_g1_index < _g1_keys.length) {
+						var key = _g1_keys[_g1_index++];
+						out[key] = obj[key];
+					};
+				};
+			};
+			process.stdout.write(JSON.stringify(out, Log.replacer) + "\n");
+		};
+	}
+	static replacer(key, val) {
+		if (val != null && typeof(val.toString) == "function" && val.toString != Object.prototype.toString) {
+			return val.toString();
+		};
+		return val;
+	}
+	static get __name__() {
+		return "whet.Log"
+	}
+	get __class__() {
+		return Log
+	}
+}
+
+
+Log.logLevel = 30
+export const LogLevel = Register.global("$hxClasses")["whet._Log.LogLevel"] = 
+class LogLevel {
+	static fromString(s) {
+		switch (s.toLowerCase()) {
+			case "debug":
+				return 20;
+				break
+			case "error":
+				return 50;
+				break
+			case "fatal":
+				return 60;
+				break
+			case "info":
+				return 30;
+				break
+			case "trace":
+				return 10;
+				break
+			case "warn":
+				return 40;
+				break
+			default:
+			return null;
+			
+		};
+	}
+	static get __name__() {
+		return "whet._Log.LogLevel_Impl_"
+	}
+	get __class__() {
+		return LogLevel
+	}
+}
+

package/bin/whet/Project.d.ts

@@ -0,0 +1,33 @@
+import {CacheManager} from "./cache/CacheManager"
+import {AnyStone} from "./Stone"
+import {Option, Command} from "commander"
+
+export declare class Project {
+	constructor(config: ProjectConfig)
+	name: string
+	id: string
+	description: string
+	rootDir: string
+	cache: CacheManager
+	onInit: (config: any) => Promise<any>
+	protected options: Option[]
+	addCommand(cmd: Command, stone?: null | AnyStone): void
+	toString(): string
+	protected static projects: Project[]
+}
+
+export type ProjectConfig = {
+	cache?: null | CacheManager, 
+	description?: null | string, 
+	id?: null | string, 
+	name: string, 
+	/**
+	* Called before first command is executed, but after configuration was parsed.
+	*/
+	onInit?: null | ((config: any) => Promise<any>), 
+	/**
+	* Array of Commander.js options this project supports.
+	*/
+	options?: null | Option[], 
+	rootDir?: null | string
+}

package/bin/whet/Project.js

@@ -0,0 +1,71 @@
+import {CacheManager} from "./cache/CacheManager.js"
+import {Whet_Fields_} from "./Whet.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.cache = null;
+		var this1 = ["Instantiating new Project."];
+		Log.log(20, ...this1);
+		if (config == null || config.name == null) {
+			throw new Error("Must supply config and a name.");
+		};
+		this.name = config.name;
+		if (config.id == null) {
+			this.id = StringTools.replace(config.name, " ", "-").toLowerCase();
+		} else {
+			this.id = config.id;
+		};
+		this.description = config.description;
+		this.options = (config.options == null) ? [] : config.options;
+		this.onInit = config.onInit;
+		if (config.rootDir == null) {
+			var oldValue = Error.prepareStackTrace;
+			Error.prepareStackTrace = function (_, stack) {
+				return stack;
+			};
+			var file = new Error().stack[3].getFileName();
+			Error.prepareStackTrace = oldValue;
+			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;
+		} 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;
+		};
+		this.cache = (config.cache == null) ? new CacheManager(this) : config.cache;
+		Project.projects.push(this);
+		var this1 = ["New project created.", {"project": this, "projectCount": Project.projects.length}];
+		Log.log(30, ...this1);
+	}
+	addCommand(cmd, stone) {
+		if (stone != null) {
+			cmd.alias(stone.id + "." + cmd.name());
+		};
+		Whet_Fields_.program.addCommand(cmd);
+	}
+	toString() {
+		return "" + this.name + "@" + this.rootDir;
+	}
+	static get __name__() {
+		return "whet.Project"
+	}
+	get __class__() {
+		return Project
+	}
+}
+
+
+Project.projects = []

package/bin/whet/Source.d.ts

@@ -0,0 +1,51 @@
+import {AnyStone} from "./Stone"
+import {SourceHash} from "./SourceHash"
+import {Buffer} from "buffer"
+
+export declare class Source {
+	protected constructor(data: SourceData[], hash: SourceHash, origin: AnyStone, ctime: number)
+	data: SourceData[]
+	hash: SourceHash
+	origin: AnyStone
+	ctime: number
+	protected dirPath: string
+	tryDirPath(): null | string
+	
+	/**
+	* Returns a directory path where this source data is stored.
+	* If none exists yet, generates a usable path through cache.
+	*/
+	getDirPath(): string
+	
+	/**
+	* Returns first result if `id` is null, or one equals to it.
+	*/
+	get(id?: null | string): SourceData
+}
+
+export declare class SourceData {
+	protected constructor(id: string, data: Buffer)
+	data: Buffer
+	id: string
+	hash: SourceHash
+	source: Source
+	protected filePathId: string
+	protected filePath: string
+	
+	/**
+	Same as `getFilePath` but relative to project, not CWD.
+	*/
+	getFilePathId(idOverride?: null | string): Promise<string>
+	
+	/**
+	Path to a file for this source, relative to CWD.
+	*/
+	getFilePath(idOverride?: null | string): Promise<string>
+	
+	/**
+	* `path` is the actual cwd-relative path. `pathId` is the project-relative source Id.
+	*/
+	static fromFile(id: string, path: string, pathId: string): Promise<SourceData>
+	static fromString(id: string, s: string): SourceData
+	static fromBytes(id: string, data: Buffer): SourceData
+}