whet 0.0.1

package/bin/whet/Whet.js

@@ -0,0 +1,117 @@
+import {Project} from "./Project.js"
+import {LogLevel, Log} from "./Log.js"
+import * as Url from "url"
+import {Register} from "../genes/Register.js"
+import {Command} from "commander"
+import {Std} from "../Std.js"
+
+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.1", "-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) {
+			var n = Std.parseInt(options.logLevel);
+			if (n == null) {
+				n = LogLevel.fromString(options.logLevel);
+			};
+			if (n == null) {
+				Whet_Fields_.program.error("Invalid value for --log-level");
+			} else {
+				Log.logLevel = n;
+			};
+		};
+		global.setImmediate(Whet_Fields_.init, options);
+	}
+	static init(options) {
+		if (Project.projects.length > 0) {
+			Whet_Fields_.initProjects();
+		} else {
+			Log.log(30, ...["Loading project.", {"file": options.project}]);
+			var path = Url.pathToFileURL(options.project).href;
+			Log.log(20, ...["Resolved project path.", {"path": path}]);
+			import(path).then(function (module) {
+				Log.log(10, ...["Project module imported."]);
+				Whet_Fields_.initProjects();
+			})["catch"](function (e) {
+				Log.log(50, ...["Error loading project.", {"error": e}]);
+				return Whet_Fields_.program.help();
+			});
+		};
+	}
+	static initProjects() {
+		Log.log(10, ...["Parsing remaining arguments.", {"args": Whet_Fields_.program.args}]);
+		var _g = 0;
+		var _g1 = Project.projects;
+		while (_g < _g1.length) {
+			var _g2 = 0;
+			var _g3 = _g1[_g++].options;
+			while (_g2 < _g3.length) Whet_Fields_.program.addOption(_g3[_g2++]);
+		};
+		Whet_Fields_.program.allowUnknownOption(false);
+		var commands = Whet_Fields_.getCommands(Whet_Fields_.program.args);
+		var initProm;
+		if (commands.length > 0) {
+			var res = Whet_Fields_.program.parseOptions(commands[0]);
+			commands[0] = res.operands.concat(res.unknown);
+			var promises = [];
+			var _g = 0;
+			var _g1 = Project.projects;
+			while (_g < _g1.length) {
+				var p = _g1[_g];
+				++_g;
+				if (p.onInit != null) {
+					var prom = p.onInit(Whet_Fields_.program.opts());
+					if (prom != null) {
+						promises.push(prom);
+					};
+				};
+			};
+			initProm = Promise.all(promises);
+		} else {
+			initProm = Promise.resolve();
+		};
+		var nextCommand = null;
+		nextCommand = function () {
+			if (commands.length == 0) {
+				return;
+			};
+			var c = commands.shift();
+			Log.log(10, ...["Executing command.", {"commandArgs": c}]);
+			Whet_Fields_.program.parseAsync(c, {"from": "user"}).then(function (_) {
+				nextCommand();
+			});
+		};
+		initProm.then(function (_) {
+			nextCommand();
+		});
+	}
+	static getCommands(args) {
+		var commands = [];
+		var from = 0;
+		var to;
+		while (true) {
+			to = args.indexOf("+", from);
+			commands.push((to < 0) ? args.slice(from) : args.slice(from, to));
+			from = to + 1;
+			if (!(to >= 0)) {
+				break;
+			};
+		};
+		return commands;
+	}
+	static get __name__() {
+		return "whet._Whet.Whet_Fields_"
+	}
+	get __class__() {
+		return Whet_Fields_
+	}
+}
+
+
+Whet_Fields_.program = new Command("whet")
+export const program = Whet_Fields_.program
+export const main = Whet_Fields_.main

package/bin/whet/cache/BaseCache.d.ts

@@ -0,0 +1,27 @@
+import {Cache, CacheDurability, DurabilityCheck} from "./Cache"
+import {AnyStone} from "../Stone"
+import {SourceHash} from "../SourceHash"
+import {Source} from "../Source"
+import {Map as Map__1} from "../../Map"
+
+export declare class BaseCache<Key, Value extends {
+	ctime: number, 
+	hash: SourceHash
+}> implements Cache {
+	constructor(rootDir: string, cache: Map__1<Key, Value[]>)
+	protected cache: Map__1<Key, Value[]>
+	protected rootDir: string
+	get(stone: AnyStone, durability: CacheDurability, check: DurabilityCheck): Promise<Source>
+	protected set(source: Source): Promise<Value>
+	getUniqueDir(stone: AnyStone, baseDir: string, hash?: null | SourceHash): string
+	protected checkDurability(stone: AnyStone, values: Value[], durability: CacheDurability, useIndex: ((arg0: Value) => number), ageIndex: ((arg0: Value) => number)): void
+	protected shouldKeep(stone: AnyStone, val: Value, durability: CacheDurability, useIndex: ((arg0: Value) => number), ageIndex: ((arg0: Value) => number)): boolean
+	protected setRecentUseOrder(values: Value[], value: Value): boolean
+	protected remove(stone: AnyStone, value: Value): Promise<any>
+	protected key(stone: AnyStone): Key
+	protected value(source: Source): Promise<Value>
+	protected source(stone: AnyStone, value: Value): Promise<Source>
+	protected getExistingDirs(stone: AnyStone): string[]
+	protected getDirFor(value: Value): string
+	toString(): string
+}

package/bin/whet/cache/BaseCache.js

@@ -0,0 +1,210 @@
+import {Cache} from "./Cache.js"
+import {SourceId} from "../SourceId.js"
+import {SourceHash} from "../SourceHash.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 {Std} from "../../Std.js"
+import {Lambda} from "../../Lambda.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const BaseCache = Register.global("$hxClasses")["whet.cache.BaseCache"] = 
+class BaseCache extends Register.inherits() {
+	new(rootDir, cache) {
+		var norm = "/" + Path.normalize((rootDir.charAt(0) == "/") ? HxOverrides.substr(rootDir, 1, null) : rootDir);
+		var tmp = (rootDir.lastIndexOf("/") == rootDir.length - 1) ? Path.addTrailingSlash(norm) : norm;
+		var s = Path.addTrailingSlash(Path.directory(rootDir));
+		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("Root dir is a not a dir.");
+		};
+		this.rootDir = rootDir;
+		this.cache = cache;
+	}
+	get(stone, durability, check) {
+		var _gthis = this;
+		Log.log(20, ...["Looking for cached source.", {"stone": stone, "cache": this}]);
+		return stone.generateHash().then(function (hash) {
+			if (hash == null) {
+				Log.log(10, ...["Generating source, because it does not supply a hash.", {"stone": stone, "cache": _gthis}]);
+			};
+			if (hash == null) {
+				return stone.generateSource(null).then(function (generatedSource) {
+					return {"generatedSource": generatedSource, "hash": generatedSource.hash};
+				});
+			} else {
+				return Promise.resolve({"generatedSource": null, "hash": hash});
+			};
+		}).then(function (data) {
+			var generatedSource = data.generatedSource;
+			var hash = data.hash;
+			var values = _gthis.cache.get(_gthis.key(stone));
+			var ageCount = function (val) {
+				return Lambda.count(values, function (v) {
+					if (v != val) {
+						return v.ctime > val.ctime;
+					} else {
+						return false;
+					};
+				});
+			};
+			var value = null;
+			if (values != null && values.length > 0) {
+				value = Lambda.find(values, function (v) {
+					return SourceHash.equals(v.hash, hash);
+				});
+				if (value != null && check._hx_index == 2 && !_gthis.shouldKeep(stone, value, durability, function (v) {
+					return 0;
+				}, ageCount)) {
+					_gthis.remove(stone, value);
+					value = null;
+				};
+				if (value != null) {
+					_gthis.setRecentUseOrder(values, value);
+				};
+			};
+			var srcPromise = ((value != null) ? _gthis.source(stone, value) : Promise.resolve(null)).then(function (src) {
+				if (src == null) {
+					Log.log(10, ...["Not cached.", {"stone": stone, "cache": _gthis}]);
+					return ((value != null) ? _gthis.remove(stone, value) : Promise.resolve(null)).then(function (_) {
+						if (check._hx_index == 1) {
+							_gthis.checkDurability(stone, values, durability, function (v) {
+								return values.indexOf(v) + 1;
+							}, function (v) {
+								return ageCount(v) + 1;
+							});
+						};
+						return ((generatedSource != null) ? Promise.resolve(generatedSource) : stone.generateSource(hash)).then(function (src) {
+							return _gthis.set(src);
+						}).then(function (val) {
+							return _gthis.source(stone, val);
+						});
+					});
+				} else {
+					Log.log(10, ...["Found in cache", {"stone": stone, "cache": _gthis}]);
+					return Promise.resolve(src);
+				};
+			});
+			srcPromise.then(function (_) {
+				if ((check == null) ? true : check._hx_index == 0) {
+					_gthis.checkDurability(stone, values, durability, function (v) {
+						return values.indexOf(v);
+					}, ageCount);
+				};
+			});
+			return srcPromise;
+		});
+	}
+	set(source) {
+		var _gthis = this;
+		var k = this.key(source.origin);
+		if (!this.cache.exists(k)) {
+			this.cache.set(k, []);
+		};
+		return this.value(source).then(function (val) {
+			_gthis.cache.get(k).unshift(val);
+			return val;
+		});
+	}
+	getUniqueDir(stone, baseDir, hash) {
+		var _gthis = this;
+		if (hash != null) {
+			var values = this.cache.get(this.key(stone));
+			if (values != null) {
+				var existingVal = Lambda.find(values, function (v) {
+					return SourceHash.equals(v.hash, hash);
+				});
+				if (existingVal != null) {
+					var existingPath = this.getDirFor(existingVal);
+					if (existingPath != null) {
+						return existingPath;
+					};
+				};
+			};
+		};
+		var filenames = this.getExistingDirs(stone);
+		var maxNum = (filenames != null) ? Lambda.fold(filenames, function (fn, num) {
+			var s = Path.addTrailingSlash(Path.directory(fn));
+			var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+			var this1 = (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm;
+			var root = _gthis.rootDir;
+			var parts = ((root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1).split("/");
+			var name = (parts.length > 1) ? parts[parts.length - 2] : "";
+			return Math.max(num, (name.charAt(0) == "v") ? Std.parseInt(HxOverrides.substr(name, 1, null)) : 0);
+		}, 0) : 0;
+		++maxNum;
+		var s = "v" + maxNum + "/";
+		var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+		return SourceId.getPutInDir((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm, baseDir);
+	}
+	checkDurability(stone, values, durability, useIndex, ageIndex) {
+		Log.log(10, ...["Checking durability.", {"stone": stone, "durability": Std.string(durability)}]);
+		if (values == null || values.length == 0) {
+			return;
+		};
+		var i = values.length;
+		while (--i > 0) if (!this.shouldKeep(stone, values[i], durability, useIndex, ageIndex)) {
+			this.remove(stone, values[i]);
+		};
+	}
+	shouldKeep(stone, val, durability, useIndex, ageIndex) {
+		var _gthis = this;
+		switch (durability._hx_index) {
+			case 0:
+				return true;
+				break
+			case 1:
+				return useIndex(val) < durability.count;
+				break
+			case 2:
+				return ageIndex(val) < durability.count;
+				break
+			case 3:
+				return Date.now() / 1000 - val.ctime <= durability.seconds;
+				break
+			case 4:
+				return durability.keep(stone, val);
+				break
+			case 5:
+				return Lambda.foreach(durability.keepIfAll, function (d) {
+					return _gthis.shouldKeep(stone, val, d, useIndex, ageIndex);
+				});
+				break
+			case 6:
+				return Lambda.exists(durability.keepIfAny, function (d) {
+					return _gthis.shouldKeep(stone, val, d, useIndex, ageIndex);
+				});
+				break
+			
+		};
+	}
+	setRecentUseOrder(values, value) {
+		if (values[0] == value) {
+			return false;
+		};
+		HxOverrides.remove(values, value);
+		values.unshift(value);
+		return true;
+	}
+	remove(stone, value) {
+		HxOverrides.remove(this.cache.get(this.key(stone)), value);
+		return Promise.resolve(null);
+	}
+	toString() {
+		var c = Boot.getClass(this);
+		return c.__name__;
+	}
+	static get __name__() {
+		return "whet.cache.BaseCache"
+	}
+	static get __interfaces__() {
+		return [Cache]
+	}
+	get __class__() {
+		return BaseCache
+	}
+}
+

package/bin/whet/cache/Cache.d.ts

@@ -0,0 +1,72 @@
+import {AnyStone} from "../Stone"
+
+export declare interface Cache {
+}
+
+export declare namespace CacheStrategy {
+	export type None = {_hx_index: 0, __enum__: "whet.cache.CacheStrategy"}
+	export const None: None
+	export type InMemory = {_hx_index: 1, durability: CacheDurability, check: null | DurabilityCheck, __enum__: "whet.cache.CacheStrategy"}
+	export const InMemory: (durability: CacheDurability, check: null | DurabilityCheck) => CacheStrategy
+	export type InFile = {_hx_index: 2, durability: CacheDurability, check: null | DurabilityCheck, __enum__: "whet.cache.CacheStrategy"}
+	export const InFile: (durability: CacheDurability, check: null | DurabilityCheck) => CacheStrategy
+	export type AbsolutePath = {_hx_index: 3, path: string, durability: CacheDurability, check: null | DurabilityCheck, __enum__: "whet.cache.CacheStrategy"}
+	export const AbsolutePath: (path: string, durability: CacheDurability, check: null | DurabilityCheck) => CacheStrategy
+}
+
+export declare type CacheStrategy = 
+	| CacheStrategy.None
+	| CacheStrategy.InMemory
+	| CacheStrategy.InFile
+	| CacheStrategy.AbsolutePath
+
+export declare namespace CacheDurability {
+	export type MaxAge = {_hx_index: 3, seconds: number, __enum__: "whet.cache.CacheDurability"}
+	export const MaxAge: (seconds: number) => CacheDurability
+	export type LimitCountByLastUse = {_hx_index: 1, count: number, __enum__: "whet.cache.CacheDurability"}
+	export const LimitCountByLastUse: (count: number) => CacheDurability
+	export type LimitCountByAge = {_hx_index: 2, count: number, __enum__: "whet.cache.CacheDurability"}
+	export const LimitCountByAge: (count: number) => CacheDurability
+	export type KeepForever = {_hx_index: 0, __enum__: "whet.cache.CacheDurability"}
+	export const KeepForever: KeepForever
+	export type Custom = {_hx_index: 4, keep: ((arg0: AnyStone, arg1: any) => boolean), __enum__: "whet.cache.CacheDurability"}
+	export const Custom: (keep: ((arg0: AnyStone, arg1: any) => boolean)) => CacheDurability
+	export type Any = {_hx_index: 6, keepIfAny: CacheDurability[], __enum__: "whet.cache.CacheDurability"}
+	export const Any: (keepIfAny: CacheDurability[]) => CacheDurability
+	export type All = {_hx_index: 5, keepIfAll: CacheDurability[], __enum__: "whet.cache.CacheDurability"}
+	export const All: (keepIfAll: CacheDurability[]) => CacheDurability
+}
+
+export declare type CacheDurability = 
+	| CacheDurability.MaxAge
+	| CacheDurability.LimitCountByLastUse
+	| CacheDurability.LimitCountByAge
+	| CacheDurability.KeepForever
+	| CacheDurability.Custom
+	| CacheDurability.Any
+	| CacheDurability.All
+
+export declare namespace DurabilityCheck {
+	export type SingleOnGet = {_hx_index: 2, __enum__: "whet.cache.DurabilityCheck"}
+	export const SingleOnGet: SingleOnGet
+	export type AllOnUse = {_hx_index: 0, __enum__: "whet.cache.DurabilityCheck"}
+	export const AllOnUse: AllOnUse
+	export type AllOnSet = {_hx_index: 1, __enum__: "whet.cache.DurabilityCheck"}
+	export const AllOnSet: AllOnSet
+}
+
+export declare type DurabilityCheck = 
+	/**
+	* Checks just the cached source when receiving it. Useful for custom durability checks
+	* and situations where the hash isn't ensuring validity.
+	*/
+	| DurabilityCheck.SingleOnGet
+	/**
+	Checks all cached sources for a stone, whenever the cache is used. The default.
+	*/
+	| DurabilityCheck.AllOnUse
+	/**
+	* Checks all cached sources for a stone, whenever any resource is being added to the cache.
+	* Improves performance, but can leave behind invalid files.
+	*/
+	| DurabilityCheck.AllOnSet

package/bin/whet/cache/Cache.js

@@ -0,0 +1,57 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Cache = {}
+
+export const CacheStrategy = 
+Register.global("$hxEnums")["whet.cache.CacheStrategy"] = 
+{
+	__ename__: "whet.cache.CacheStrategy",
+	
+	None: {_hx_name: "None", _hx_index: 0, __enum__: "whet.cache.CacheStrategy"},
+	InMemory: Object.assign((durability, check) => ({_hx_index: 1, __enum__: "whet.cache.CacheStrategy", "durability": durability, "check": check}), {_hx_name: "InMemory", __params__: ["durability", "check"]}),
+	InFile: Object.assign((durability, check) => ({_hx_index: 2, __enum__: "whet.cache.CacheStrategy", "durability": durability, "check": check}), {_hx_name: "InFile", __params__: ["durability", "check"]}),
+	AbsolutePath: Object.assign((path, durability, check) => ({_hx_index: 3, __enum__: "whet.cache.CacheStrategy", "path": path, "durability": durability, "check": check}), {_hx_name: "AbsolutePath", __params__: ["path", "durability", "check"]})
+}
+CacheStrategy.__constructs__ = [CacheStrategy.None, CacheStrategy.InMemory, CacheStrategy.InFile, CacheStrategy.AbsolutePath]
+CacheStrategy.__empty_constructs__ = [CacheStrategy.None]
+
+export const CacheDurability = 
+Register.global("$hxEnums")["whet.cache.CacheDurability"] = 
+{
+	__ename__: "whet.cache.CacheDurability",
+	
+	KeepForever: {_hx_name: "KeepForever", _hx_index: 0, __enum__: "whet.cache.CacheDurability"},
+	LimitCountByLastUse: Object.assign((count) => ({_hx_index: 1, __enum__: "whet.cache.CacheDurability", "count": count}), {_hx_name: "LimitCountByLastUse", __params__: ["count"]}),
+	LimitCountByAge: Object.assign((count) => ({_hx_index: 2, __enum__: "whet.cache.CacheDurability", "count": count}), {_hx_name: "LimitCountByAge", __params__: ["count"]}),
+	MaxAge: Object.assign((seconds) => ({_hx_index: 3, __enum__: "whet.cache.CacheDurability", "seconds": seconds}), {_hx_name: "MaxAge", __params__: ["seconds"]}),
+	Custom: Object.assign((keep) => ({_hx_index: 4, __enum__: "whet.cache.CacheDurability", "keep": keep}), {_hx_name: "Custom", __params__: ["keep"]}),
+	All: Object.assign((keepIfAll) => ({_hx_index: 5, __enum__: "whet.cache.CacheDurability", "keepIfAll": keepIfAll}), {_hx_name: "All", __params__: ["keepIfAll"]}),
+	Any: Object.assign((keepIfAny) => ({_hx_index: 6, __enum__: "whet.cache.CacheDurability", "keepIfAny": keepIfAny}), {_hx_name: "Any", __params__: ["keepIfAny"]})
+}
+CacheDurability.__constructs__ = [CacheDurability.KeepForever, CacheDurability.LimitCountByLastUse, CacheDurability.LimitCountByAge, CacheDurability.MaxAge, CacheDurability.Custom, CacheDurability.All, CacheDurability.Any]
+CacheDurability.__empty_constructs__ = [CacheDurability.KeepForever]
+
+export const DurabilityCheck = 
+Register.global("$hxEnums")["whet.cache.DurabilityCheck"] = 
+{
+	__ename__: "whet.cache.DurabilityCheck",
+	
+	/**
+	Checks all cached sources for a stone, whenever the cache is used. The default.
+	*/
+	AllOnUse: {_hx_name: "AllOnUse", _hx_index: 0, __enum__: "whet.cache.DurabilityCheck"},
+	/**
+	* Checks all cached sources for a stone, whenever any resource is being added to the cache.
+	* Improves performance, but can leave behind invalid files.
+	*/
+	AllOnSet: {_hx_name: "AllOnSet", _hx_index: 1, __enum__: "whet.cache.DurabilityCheck"},
+	/**
+	* Checks just the cached source when receiving it. Useful for custom durability checks
+	* and situations where the hash isn't ensuring validity.
+	*/
+	SingleOnGet: {_hx_name: "SingleOnGet", _hx_index: 2, __enum__: "whet.cache.DurabilityCheck"}
+}
+DurabilityCheck.__constructs__ = [DurabilityCheck.AllOnUse, DurabilityCheck.AllOnSet, DurabilityCheck.SingleOnGet]
+DurabilityCheck.__empty_constructs__ = [DurabilityCheck.AllOnUse, DurabilityCheck.AllOnSet, DurabilityCheck.SingleOnGet]

package/bin/whet/cache/CacheManager.d.ts

@@ -0,0 +1,23 @@
+import {MemoryCache} from "./MemoryCache"
+import {FileCache} from "./FileCache"
+import {CacheStrategy} from "./Cache"
+import {AnyStone} from "../Stone"
+import {SourceHash} from "../SourceHash"
+import {Source} from "../Source"
+import {Project} from "../Project"
+
+export declare class CacheManager {
+	constructor(project: Project)
+	project: Project
+	defaultStrategy: CacheStrategy
+	protected memCache: MemoryCache
+	protected fileCache: FileCache
+	getSource(stone: AnyStone): Promise<Source>
+	
+	/**
+	* Get valid directory to generate files in. The path is unique per stone based on caching rules.
+	* If hash is supplied, and a path was already assigned, the same path is returned, assuring consistency.
+	* The path is not reserved. Caching depends on stone's `cacheStrategy` and success of source generation.
+	*/
+	getDir(stone: AnyStone, hash?: null | SourceHash): string
+}

package/bin/whet/cache/CacheManager.js

@@ -0,0 +1,103 @@
+import {MemoryCache} from "./MemoryCache.js"
+import {FileCache} from "./FileCache.js"
+import {CacheStrategy, DurabilityCheck} from "./Cache.js"
+import {RootDir, SourceId} from "../SourceId.js"
+import {Log} from "../Log.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 CacheManager = Register.global("$hxClasses")["whet.cache.CacheManager"] = 
+class CacheManager extends Register.inherits() {
+	new(project) {
+		this.fileCache = null;
+		this.memCache = null;
+		this.defaultStrategy = CacheStrategy.None;
+		this.project = project;
+		this.fileCache = new FileCache(RootDir.fromProject(project));
+		this.memCache = new MemoryCache(RootDir.fromProject(project));
+	}
+	getSource(stone) {
+		var e = stone.cacheStrategy;
+		Log.log(10, ...["Looking for cached value.", {"stone": stone, "strategy": Register.global("$hxEnums")[e.__enum__].__constructs__[e._hx_index]._hx_name}]);
+		var _g = stone.cacheStrategy;
+		switch (_g._hx_index) {
+			case 0:
+				return stone.generateHash().then(function (hash) {
+					return stone.generateSource(hash);
+				});
+				break
+			case 1:
+				var _g1 = _g.check;
+				return this.memCache.get(stone, _g.durability, (_g1 != null) ? _g1 : DurabilityCheck.AllOnUse);
+				break
+			case 2:
+				var _g1 = _g.check;
+				return this.fileCache.get(stone, _g.durability, (_g1 != null) ? _g1 : DurabilityCheck.AllOnUse);
+				break
+			case 3:
+				var _g1 = _g.check;
+				return this.fileCache.get(stone, _g.durability, (_g1 != null) ? _g1 : DurabilityCheck.AllOnUse);
+				break
+			
+		};
+	}
+	
+	/**
+	* Get valid directory to generate files in. The path is unique per stone based on caching rules.
+	* If hash is supplied, and a path was already assigned, the same path is returned, assuring consistency.
+	* The path is not reserved. Caching depends on stone's `cacheStrategy` and success of source generation.
+	*/
+	getDir(stone, hash) {
+		var s = stone.id + "/";
+		var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+		var baseDir = (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm;
+		var tmp;
+		switch (stone.cacheStrategy._hx_index) {
+			case 0:
+				tmp = true;
+				break
+			case 1:
+				tmp = true;
+				break
+			default:
+			tmp = false;
+			
+		};
+		if (tmp) {
+			var norm = "/" + Path.normalize((".temp/".charAt(0) == "/") ? HxOverrides.substr(".temp/", 1, null) : ".temp/");
+			baseDir = SourceId.getPutInDir(baseDir, (".temp/".lastIndexOf("/") == ".temp/".length - 1) ? Path.addTrailingSlash(norm) : norm);
+		};
+		var norm = "/" + Path.normalize((".whet/".charAt(0) == "/") ? HxOverrides.substr(".whet/", 1, null) : ".whet/");
+		baseDir = SourceId.getPutInDir(baseDir, (".whet/".lastIndexOf("/") == ".whet/".length - 1) ? Path.addTrailingSlash(norm) : norm);
+		var id;
+		var _g = stone.cacheStrategy;
+		switch (_g._hx_index) {
+			case 0:
+				id = baseDir;
+				break
+			case 1:
+				id = this.memCache.getUniqueDir(stone, baseDir, hash);
+				break
+			case 2:
+				id = this.fileCache.getUniqueDir(stone, baseDir, hash);
+				break
+			case 3:
+				var s = Path.addTrailingSlash(Path.directory(_g.path));
+				var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+				id = (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm;
+				break
+			
+		};
+		return id;
+	}
+	static get __name__() {
+		return "whet.cache.CacheManager"
+	}
+	get __class__() {
+		return CacheManager
+	}
+}
+

package/bin/whet/cache/FileCache.d.ts

@@ -0,0 +1,35 @@
+import {BaseCache} from "./BaseCache"
+import {AnyStone} from "../Stone"
+import {SourceHash} from "../SourceHash"
+import {Source} from "../Source"
+
+export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue> {
+	constructor(rootDir: string)
+	protected dbFile: string
+	protected flushQueued: boolean
+	protected key(stone: AnyStone): string
+	protected value(source: Source): Promise<RuntimeFileCacheValue>
+	protected source(stone: AnyStone, value: RuntimeFileCacheValue): Promise<Source>
+	protected set(source: Source): Promise<RuntimeFileCacheValue>
+	protected getExistingDirs(stone: AnyStone): string[]
+	protected remove(stone: AnyStone, value: RuntimeFileCacheValue): Promise<any>
+	protected setRecentUseOrder(values: RuntimeFileCacheValue[], value: RuntimeFileCacheValue): boolean
+	protected getDirFor(value: RuntimeFileCacheValue): string
+	protected flush(): void
+}
+
+export type FileCacheValue<H, S> = {
+	baseDir: S, 
+	ctime: number, 
+	ctimePretty?: null | string, 
+	files: {
+		fileHash: H, 
+		filePath: S, 
+		id: S
+	}[], 
+	hash: H
+}
+
+export type DbJson = {[key: string]: FileCacheValue<string, string>[]}
+
+export type RuntimeFileCacheValue = FileCacheValue<SourceHash, string>