whet 0.0.1

package/bin/whet/Source.js

@@ -0,0 +1,136 @@
+import {Utils} from "./Utils.js"
+import {SourceId, RootDir} from "./SourceId.js"
+import {SourceHash} from "./SourceHash.js"
+import {Log} from "./Log.js"
+import {Register} from "../genes/Register.js"
+import * as Fs from "fs"
+import {Buffer} from "buffer"
+import {Lambda} from "../Lambda.js"
+
+const $global = Register.$global
+
+export const Source = Register.global("$hxClasses")["whet.Source"] = 
+class Source extends Register.inherits() {
+	new(data, hash, origin, ctime) {
+		this.dirPath = null;
+		this.data = data;
+		this.hash = hash;
+		this.origin = origin;
+		this.ctime = ctime;
+		var _g = 0;
+		while (_g < data.length) data[_g++].source = this;
+	}
+	tryDirPath() {
+		return this.dirPath;
+	}
+	
+	/**
+	* Returns a directory path where this source data is stored.
+	* If none exists yet, generates a usable path through cache.
+	*/
+	getDirPath() {
+		if (this.dirPath == null) {
+			this.dirPath = this.origin.project.cache.getDir(this.origin, this.hash);
+		};
+		return this.dirPath;
+	}
+	
+	/**
+	* Returns first result if `id` is null, or one equals to it.
+	*/
+	get(id) {
+		if (id == null) {
+			return this.data[0];
+		} else {
+			return Lambda.find(this.data, function (entry) {
+				return entry.id == id;
+			});
+		};
+	}
+	static get __name__() {
+		return "whet.Source"
+	}
+	get __class__() {
+		return Source
+	}
+}
+
+
+export const SourceData = Register.global("$hxClasses")["whet.SourceData"] = 
+class SourceData extends Register.inherits() {
+	new(id, data) {
+		this.filePath = null;
+		this.filePathId = null;
+		this.data = data;
+		this.id = id;
+		this.hash = SourceHash.fromBytes(data);
+	}
+	
+	/**
+	Same as `getFilePath` but relative to project, not CWD.
+	*/
+	getFilePathId(idOverride) {
+		var _gthis = this;
+		if (this.filePathId == null) {
+			return this.getFilePath(idOverride).then(function (_) {
+				return _gthis.filePathId;
+			});
+		} else {
+			return Promise.resolve(this.filePathId);
+		};
+	}
+	
+	/**
+	Path to a file for this source, relative to CWD.
+	*/
+	getFilePath(idOverride) {
+		var _gthis = this;
+		if (this.filePath == null) {
+			if (this.source == null) {
+				new Error("Data without source.");
+			};
+			var dir = this.source.getDirPath();
+			this.filePathId = SourceId.getPutInDir((idOverride != null) ? idOverride : this.id, dir);
+			var this1 = this.filePathId;
+			var root = RootDir.fromProject(this.source.origin.project);
+			this.filePath = (root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1;
+			return Utils.saveBytes(this.filePath, this.data).then(function (_) {
+				return _gthis.filePath;
+			});
+		} else {
+			return Promise.resolve(this.filePath);
+		};
+	}
+	
+	/**
+	* `path` is the actual cwd-relative path. `pathId` is the project-relative source Id.
+	*/
+	static fromFile(id, path, pathId) {
+		return new Promise(function (res, rej) {
+			Fs.readFile(path, function (err, buffer) {
+				if (err != null) {
+					Log.log(50, ...["File does not exist.", {"id": id, "path": path}]);
+					res(null);
+				} else {
+					var source = SourceData.fromBytes(id, buffer);
+					source.filePath = path;
+					source.filePathId = pathId;
+					res(source);
+				};
+			});
+		});
+	}
+	static fromString(id, s) {
+		return SourceData.fromBytes(id, Buffer.from(s, "utf-8"));
+	}
+	static fromBytes(id, data) {
+		return new SourceData(id, data);
+	}
+	static get __name__() {
+		return "whet.SourceData"
+	}
+	get __class__() {
+		return SourceData
+	}
+}
+

package/bin/whet/SourceHash.d.ts

@@ -0,0 +1,15 @@
+import {Buffer} from "buffer"
+
+export declare class SourceHash {
+	protected constructor(bytes: Buffer)
+	protected bytes: Buffer
+	toString(): string
+	static EMPTY: SourceHash
+	static fromBytes(data: Buffer): SourceHash
+	static fromString(data: string): SourceHash
+	static add(a: SourceHash, b: SourceHash): SourceHash
+	static equals(a: SourceHash, b: SourceHash): boolean
+	static toHex(hash: SourceHash): string
+	static fromHex(hex: string): SourceHash
+	static merge(...hash: SourceHash[]): SourceHash
+}

package/bin/whet/SourceHash.js

@@ -0,0 +1,68 @@
+import {Register} from "../genes/Register.js"
+import * as Crypto from "crypto"
+import {Buffer} from "buffer"
+
+const $global = Register.$global
+
+export const SourceHash = Register.global("$hxClasses")["whet.SourceHash"] = 
+class SourceHash extends Register.inherits() {
+	new(bytes) {
+		this.bytes = bytes;
+	}
+	toString() {
+		return this.bytes.toString("hex");
+	}
+	static fromBytes(data) {
+		return new SourceHash(Crypto.createHash("sha256").update(data).digest());
+	}
+	static fromString(data) {
+		return SourceHash.fromBytes(Buffer.from(data));
+	}
+	static add(a, b) {
+		var data = Buffer.alloc(64);
+		a.bytes.copy(data, 0, 0, 32);
+		b.bytes.copy(data, 32, 0, 32);
+		return SourceHash.fromBytes(data);
+	}
+	static equals(a, b) {
+		if (a != null && b != null) {
+			return a.bytes.compare(b.bytes) == 0;
+		} else {
+			return false;
+		};
+	}
+	static toHex(hash) {
+		if (hash == null) {
+			return "";
+		} else {
+			return hash.toString();
+		};
+	}
+	static fromHex(hex) {
+		var hash = Buffer.from(hex, "hex");
+		if (hash.length != 32) {
+			return null;
+		} else {
+			return new SourceHash(hash);
+		};
+	}
+	static merge(...hash) {
+		if (hash.length == 0) {
+			return SourceHash.EMPTY;
+		};
+		var h = hash[0];
+		var _g = 1;
+		var _g1 = hash.length;
+		while (_g < _g1) h = SourceHash.add(h, hash[_g++]);
+		return h;
+	}
+	static get __name__() {
+		return "whet.SourceHash"
+	}
+	get __class__() {
+		return SourceHash
+	}
+}
+
+
+SourceHash.EMPTY = new SourceHash(Buffer.alloc(32))

package/bin/whet/SourceId.d.ts

@@ -0,0 +1,10 @@
+import {Project} from "./Project"
+
+export declare class SourceId {
+	static relativeTo($this: string, directory: string): string
+	static getPutInDir($this: string, dir: string): string
+}
+
+export declare class RootDir {
+	static fromProject(p: Project): string
+}

package/bin/whet/SourceId.js

@@ -0,0 +1,74 @@
+import {Path} from "../haxe/io/Path.js"
+import {Register} from "../genes/Register.js"
+import {HxOverrides} from "../HxOverrides.js"
+
+const $global = Register.$global
+
+export const SourceId = Register.global("$hxClasses")["whet._SourceId.SourceId"] = 
+class SourceId {
+	static relativeTo(this1, directory) {
+		var norm = "/" + Path.normalize((directory.charAt(0) == "/") ? HxOverrides.substr(directory, 1, null) : directory);
+		var tmp = (directory.lastIndexOf("/") == directory.length - 1) ? Path.addTrailingSlash(norm) : norm;
+		var s = Path.addTrailingSlash(Path.directory(directory));
+		var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+		if (tmp != ((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm)) {
+			throw new Error("\"" + directory + "\" is not a directory.");
+		};
+		var tmp;
+		var s = Path.addTrailingSlash(Path.directory(this1));
+		var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+		tmp = ((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm).indexOf(directory) == 0;
+		if (tmp) {
+			return HxOverrides.substr(this1, directory.length - 1, null);
+		} else {
+			return null;
+		};
+	}
+	static getPutInDir(this1, dir) {
+		var norm = "/" + Path.normalize((dir.charAt(0) == "/") ? HxOverrides.substr(dir, 1, null) : dir);
+		var tmp = (dir.lastIndexOf("/") == dir.length - 1) ? Path.addTrailingSlash(norm) : norm;
+		var s = Path.addTrailingSlash(Path.directory(dir));
+		var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+		if (tmp != ((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm)) {
+			throw new Error("\"" + dir + "\" is not a directory.");
+		};
+		var norm = "/" + Path.normalize(("/".charAt(0) == "/") ? HxOverrides.substr("/", 1, null) : "/");
+		if (dir == (("/".lastIndexOf("/") == "/".length - 1) ? Path.addTrailingSlash(norm) : norm)) {
+			var norm = "/" + Path.normalize((this1.charAt(0) == "/") ? HxOverrides.substr(this1, 1, null) : this1);
+			if (this1.lastIndexOf("/") == this1.length - 1) {
+				return Path.addTrailingSlash(norm);
+			} else {
+				return norm;
+			};
+		} else {
+			var s = dir + this1;
+			var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+			if (s.lastIndexOf("/") == s.length - 1) {
+				return Path.addTrailingSlash(norm);
+			} else {
+				return norm;
+			};
+		};
+	}
+	static get __name__() {
+		return "whet._SourceId.SourceId_Impl_"
+	}
+	get __class__() {
+		return SourceId
+	}
+}
+
+
+export const RootDir = Register.global("$hxClasses")["whet._SourceId.RootDir"] = 
+class RootDir {
+	static fromProject(p) {
+		return p.rootDir;
+	}
+	static get __name__() {
+		return "whet._SourceId.RootDir_Impl_"
+	}
+	get __class__() {
+		return RootDir
+	}
+}
+

package/bin/whet/Stone.d.ts

@@ -0,0 +1,88 @@
+import {StoneIdType} from "./magic/StoneId"
+import {CacheStrategy} from "./cache/Cache"
+import {SourceHash} from "./SourceHash"
+import {Source, SourceData} from "./Source"
+import {Project} from "./Project"
+import {Command} from "commander"
+
+export declare class Stone<T extends StoneConfig> {
+	constructor(config: T)
+	config: T
+	
+	/**
+	If true, hash of a cached file (not `stone.getHash()` but actual file contents) won't be checked.
+	*/
+	ignoreFileHash: boolean
+	id: string
+	cacheStrategy: CacheStrategy
+	project: Project
+	
+	/**
+	Override this to set config defaults.
+	*/
+	protected initConfig(): void
+	
+	/**
+	Override this to register commands.
+	*/
+	protected getCommands(): Command[]
+	
+	/**
+	Get Source for this stone. Goes through the cache.
+	*/
+	getSource(): Promise<Source>
+	
+	/**
+	Hash of this stone with its current config. Defaults to hash of generated source.
+	*/
+	getHash(): Promise<SourceHash>
+	
+	/**
+	* Generates new Source. Used by the cache when needed.
+	* Hash passed should be the same as is this stone's current one. Passed in as optimization.
+	*/
+	protected generateSource(hash: SourceHash): Promise<Source>
+	
+	/**
+	* Optionally overridable hash generation as optimization.
+	*/
+	protected generateHash(): Promise<SourceHash>
+	
+	/**
+	* Function that actually generates the source. Passed hash is only non-null
+	* if `generateHash()` is implemented. It can be used for `CacheManager.getDir` and
+	* is passed mainly as optimization.
+	*/
+	protected generate(hash: SourceHash): Promise<SourceData[]>
+	
+	/**
+	* Returns a list of sources that this stone generates.
+	* Used by Router for finding the correct asset.
+	* Default implementation generates the sources to find their ids, but can be overriden
+	* to provide optimized implementation that would avoid generating assets we might not need.
+	*/
+	list(): Promise<string[]>
+	
+	/**
+	* Caches this resource under supplied `path` as a single copy.
+	* If `path` is a directory, stores the file(s) under that path, using their standard names.
+	* If `path` is a file and this stone generates only single data source, stores it under the supplied path.
+	* If `generate` is true, the source is exported right away.
+	*/
+	setAbsolutePath(path: string, generate?: boolean): Promise<Source>
+	toString(): string
+}
+
+export type StoneConfig = {
+	cacheStrategy?: null | CacheStrategy, 
+	/**
+	Defaults to the Stone's class name.
+	*/
+	id?: null | StoneIdType, 
+	/**
+	Defaults to the last instanced project.
+	*/
+	project?: null | Project
+}
+
+export type AnyStone = Stone<any>

package/bin/whet/Stone.js

@@ -0,0 +1,157 @@
+import {StoneId_Fields_} from "./magic/StoneId.js"
+import {CacheStrategy, CacheDurability} from "./cache/Cache.js"
+import {SourceHash} from "./SourceHash.js"
+import {Source} from "./Source.js"
+import {Project} from "./Project.js"
+import {Log} from "./Log.js"
+import {Boot} from "../js/Boot.js"
+import {Path} from "../haxe/io/Path.js"
+import {Register} from "../genes/Register.js"
+import {HxOverrides} from "../HxOverrides.js"
+
+const $global = Register.$global
+
+export const Stone = Register.global("$hxClasses")["whet.Stone"] = 
+class Stone extends Register.inherits() {
+	new(config) {
+		this.ignoreFileHash = false;
+		var c = Boot.getClass(this);
+		Log.log(10, ...["Instantiating new Stone.", {"type": c.__name__}]);
+		if (config == null) {
+			throw new Error("Config must be supplied.");
+		};
+		this.config = config;
+		this.initConfig();
+		this.id = (config.id != null) ? StoneId_Fields_.makeStoneId(config.id) : StoneId_Fields_.makeStoneId(this);
+		this.project = (config.project != null) ? config.project : Project.projects[Project.projects.length - 1];
+		if (this.project == null) {
+			throw new Error("Did not find a project. Create one before creating stones.");
+		};
+		this.cacheStrategy = (config.cacheStrategy == null) ? this.project.cache.defaultStrategy : config.cacheStrategy;
+		var _g = 0;
+		var _g1 = this.getCommands();
+		while (_g < _g1.length) this.project.addCommand(_g1[_g++], this);
+	}
+	
+	/**
+	Override this to set config defaults.
+	*/
+	initConfig() {
+	}
+	
+	/**
+	Override this to register commands.
+	*/
+	getCommands() {
+		return [];
+	}
+	
+	/**
+	Get Source for this stone. Goes through the cache.
+	*/
+	getSource() {
+		Log.log(20, ...["Getting source.", {"stone": this}]);
+		return this.project.cache.getSource(this);
+	}
+	
+	/**
+	Hash of this stone with its current config. Defaults to hash of generated source.
+	*/
+	getHash() {
+		var _gthis = this;
+		Log.log(20, ...["Generating hash.", {"stone": this}]);
+		return this.generateHash().then(function (hash) {
+			if (hash != null) {
+				return hash;
+			} else {
+				return _gthis.getSource().then(function (s) {
+					return s.hash;
+				});
+			};
+		});
+	}
+	
+	/**
+	* Generates new Source. Used by the cache when needed.
+	* Hash passed should be the same as is this stone's current one. Passed in as optimization.
+	*/
+	generateSource(hash) {
+		var _gthis = this;
+		Log.log(20, ...["Generating source.", {"stone": this, "hash": hash}]);
+		var dataPromise = this.generate(hash);
+		if (dataPromise != null) {
+			return dataPromise.then(function (data) {
+				if (hash == null) {
+					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);
+					};
+					hash = SourceHash.merge(...result);
+				};
+				return new Source(data, hash, _gthis, Date.now() / 1000);
+			});
+		} else {
+			return null;
+		};
+	}
+	
+	/**
+	* Optionally overridable hash generation as optimization.
+	*/
+	generateHash() {
+		return Promise.resolve(null);
+	}
+	
+	/**
+	* Returns a list of sources that this stone generates.
+	* Used by Router for finding the correct asset.
+	* Default implementation generates the sources to find their ids, but can be overriden
+	* to provide optimized implementation that would avoid generating assets we might not need.
+	*/
+	list() {
+		return this.getSource().then(function (source) {
+			var _this = source.data;
+			var result = new Array(_this.length);
+			var _g = 0;
+			var _g1 = _this.length;
+			while (_g < _g1) {
+				var i = _g++;
+				result[i] = _this[i].id;
+			};
+			return result;
+		});
+	}
+	
+	/**
+	* Caches this resource under supplied `path` as a single copy.
+	* If `path` is a directory, stores the file(s) under that path, using their standard names.
+	* If `path` is a file and this stone generates only single data source, stores it under the supplied path.
+	* If `generate` is true, the source is exported right away.
+	*/
+	setAbsolutePath(path, generate) {
+		if (generate == null) {
+			generate = true;
+		};
+		var norm = "/" + Path.normalize((path.charAt(0) == "/") ? HxOverrides.substr(path, 1, null) : path);
+		this.cacheStrategy = CacheStrategy.AbsolutePath((path.lastIndexOf("/") == path.length - 1) ? Path.addTrailingSlash(norm) : norm, CacheDurability.LimitCountByAge(1));
+		if (generate) {
+			return this.getSource();
+		} else {
+			return Promise.resolve(null);
+		};
+	}
+	toString() {
+		var c = Boot.getClass(this);
+		return "" + this.id + ":" + c.__name__;
+	}
+	static get __name__() {
+		return "whet.Stone"
+	}
+	get __class__() {
+		return Stone
+	}
+}
+

package/bin/whet/Utils.d.ts

@@ -0,0 +1,16 @@
+import {Buffer} from "buffer"
+
+export declare class Utils {
+	static ensureDirExist(path: string): Promise<any>
+	
+	/**
+	Saves string as UTF-8, creates missing directories if needed.
+	*/
+	static saveContent(path: string, content: string): Promise<any>
+	
+	/**
+	Saves bytes Buffer, creates missing directories if needed.
+	*/
+	static saveBytes(path: string, bytes: Buffer): Promise<any>
+	static deleteAll(path: string): Promise<any>
+}

package/bin/whet/Utils.js

@@ -0,0 +1,72 @@
+import {Log} from "./Log.js"
+import * as Path from "path"
+import {Register} from "../genes/Register.js"
+import * as Fs from "fs"
+import {Buffer} from "buffer"
+
+const $global = Register.$global
+
+export const Utils = Register.global("$hxClasses")["whet.Utils"] = 
+class Utils {
+	static ensureDirExist(path) {
+		var dir = Path.dirname(path);
+		var this1 = ["Ensuring directory " + dir + " exists."];
+		Log.log(10, ...this1);
+		return new Promise(function (res, rej) {
+			Fs.stat(dir, function (err, stats) {
+				if (err != null) {
+					Fs.mkdir(dir, {"recursive": true}, function (err) {
+						if (err != null) {
+							rej(err);
+						} else {
+							res(null);
+						};
+					});
+				} else if (!stats.isDirectory()) {
+					rej(new Error("Path exists, but is not a directory."));
+				} else {
+					res(null);
+				};
+			});
+		});
+	}
+	
+	/**
+	Saves string as UTF-8, creates missing directories if needed.
+	*/
+	static saveContent(path, content) {
+		return Utils.saveBytes(path, Buffer.from(content, "utf-8"));
+	}
+	
+	/**
+	Saves bytes Buffer, creates missing directories if needed.
+	*/
+	static saveBytes(path, bytes) {
+		Log.log(10, ...["Writing bytes to " + path + "."]);
+		return Utils.ensureDirExist(path).then(function (_) {
+			return new Promise(function (res, rej) {
+				Fs.writeFile(path, bytes, function (err) {
+					if (err != null) {
+						rej(err);
+					} else {
+						res(null);
+					};
+				});
+			});
+		});
+	}
+	static deleteAll(path) {
+		return new Promise(function (res, rej) {
+			Fs.rm(path, { recursive : true, force : true}, function(_) {
+	res(null);
+});
+		});
+	}
+	static get __name__() {
+		return "whet.Utils"
+	}
+	get __class__() {
+		return Utils
+	}
+}
+

package/bin/whet/Whet.d.ts

@@ -0,0 +1,4 @@
+import {Command} from "commander"
+
+export const program: Command
+export const main: () => void