whet 0.0.34 → 0.1.0

package/bin/whet/cache/CacheManager.js

@@ -10,7 +10,7 @@ const $global = Register.$global
 
 export const CacheManager = Register.global("$hxClasses")["whet.cache.CacheManager"] = 
 class CacheManager extends Register.inherits() {
-	new(project) {
+	[Register.new](project) {
 		this.defaultFileStrategy = CacheStrategy.InFile(CacheDurability.Any([CacheDurability.LimitCountByLastUse(1), CacheDurability.All([CacheDurability.MaxAge(86400), CacheDurability.LimitCountByLastUse(5)])]), DurabilityCheck.AllOnUse);
 		this.fileCache = null;
 		this.memCache = null;
@@ -46,6 +46,33 @@ class CacheManager extends Register.inherits() {
 			
 		};
 	}
+	getPartialSource(stone, sourceId) {
+		let _g = stone.cacheStrategy;
+		switch (_g._hx_index) {
+			case 0:
+				return stone.acquire(function () {
+					return stone.finalMaybeHash().then(function (hash) {
+						return stone.generatePartialSource(sourceId, hash).then(function (r) {
+							return r.source.filterTo(sourceId);
+						});
+					});
+				});
+				break
+			case 1:
+				let _g1 = _g.check;
+				return this.memCache.getPartial(stone, sourceId, _g.durability, (_g1 != null) ? _g1 : DurabilityCheck.AllOnUse);
+				break
+			case 2:
+				let _g2 = _g.check;
+				return this.fileCache.getPartial(stone, sourceId, _g.durability, (_g2 != null) ? _g2 : DurabilityCheck.AllOnUse);
+				break
+			case 3:
+				let _g3 = _g.check;
+				return this.fileCache.getPartial(stone, sourceId, _g.durability, (_g3 != null) ? _g3 : DurabilityCheck.AllOnUse);
+				break
+			
+		};
+	}
 	
 	/**
 	* Re-generates source even if the currently cached value is valid.
@@ -79,7 +106,8 @@ class CacheManager extends Register.inherits() {
 	* The path is not reserved. Caching depends on stone's `cacheStrategy` and success of source generation.
 	*/
 	getDir(stone, hash) {
-		let baseDir = stone.id + "/";
+		let _this_r = new RegExp("[^a-zA-Z0-9_\\-.]", "g".split("u").join(""));
+		let baseDir = stone.id.replace(_this_r, "_") + "/";
 		let tmp;
 		switch (stone.cacheStrategy._hx_index) {
 			case 0:
@@ -123,6 +151,9 @@ class CacheManager extends Register.inherits() {
 		};
 		return id;
 	}
+	close() {
+		return this.fileCache.close();
+	}
 	static get __name__() {
 		return "whet.cache.CacheManager"
 	}
@@ -130,4 +161,9 @@ class CacheManager extends Register.inherits() {
 		return CacheManager
 	}
 }
+CacheManager.prototype.project = null;
+CacheManager.prototype.defaultStrategy = null;
+CacheManager.prototype.memCache = null;
+CacheManager.prototype.fileCache = null;
+CacheManager.prototype.defaultFileStrategy = null;
 

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

@@ -6,7 +6,9 @@ import {Source} from "../Source"
 export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue> {
 	constructor(rootDir: string)
 	protected dbFile: string
-	protected flushQueued: boolean
+	protected flushTimerId: any
+	protected flushResolve: (arg0: any) => void
+	protected flushPromise: Promise<void>
 	protected key(stone: AnyStone): string
 	protected value(source: Source): Promise<RuntimeFileCacheValue>
 	protected source(stone: AnyStone, value: RuntimeFileCacheValue): Promise<Source>
@@ -15,11 +17,17 @@ export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue>
 	protected remove(stone: AnyStone, value: RuntimeFileCacheValue): Promise<any>
 	protected setRecentUseOrder(values: RuntimeFileCacheValue[], value: RuntimeFileCacheValue): boolean
 	protected getDirFor(value: RuntimeFileCacheValue): string
-	protected flush(): void
+	protected hasSourceId(value: RuntimeFileCacheValue, sourceId: string): boolean
+	protected mergePartial(stone: AnyStone, existing: RuntimeFileCacheValue, addition: Source, markComplete: boolean): Promise<RuntimeFileCacheValue>
+	protected replaceEntry(stone: AnyStone, existing: RuntimeFileCacheValue, replacement: Source): Promise<RuntimeFileCacheValue>
+	protected flush(): Promise<void>
+	protected doFlush(): void
+	close(): Promise<void>
 }
 
 export type FileCacheValue<H, S> = {
 	baseDir: S, 
+	complete: boolean, 
 	ctime: number, 
 	ctimePretty?: null | string, 
 	files: {

package/bin/whet/cache/FileCache.js

@@ -16,9 +16,11 @@ const $global = Register.$global
 
 export const FileCache = Register.global("$hxClasses")["whet.cache.FileCache"] = 
 class FileCache extends Register.inherits(() => BaseCache, true) {
-	new(rootDir) {
-		this.flushQueued = false;
-		super.new(rootDir, new StringMap());
+	[Register.new](rootDir) {
+		this.flushPromise = null;
+		this.flushResolve = null;
+		this.flushTimerId = null;
+		super[Register.new](rootDir, new StringMap());
 		this.dbFile = Path.posix.join(".", rootDir, ".", ".whet/cache.json");
 		try {
 			let db = JSON.parse(Fs.readFileSync(this.dbFile, {"encoding": "utf-8"}));
@@ -36,6 +38,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 					let tmp = SourceHash.fromHex(val.hash);
 					let val1 = val.ctime;
 					let val2 = val.baseDir;
+					let tmp1 = (val.complete != null) ? val.complete : true;
 					let _g2 = [];
 					let _g3 = 0;
 					let _g4 = val.files;
@@ -44,7 +47,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 						++_g3;
 						_g2.push({"fileHash": SourceHash.fromHex(file.fileHash), "filePath": file.filePath, "id": file.id, "mtime": file.mtime, "size": file.size});
 					};
-					_g.push({"hash": tmp, "ctime": val1, "baseDir": val2, "files": _g2});
+					_g.push({"hash": tmp, "ctime": val1, "baseDir": val2, "complete": tmp1, "files": _g2});
 				};
 				this1.inst.set(key, _g);
 			};
@@ -78,7 +81,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			}));
 		};
 		return Promise.all(_g1).then(function (files) {
-			return {"hash": source.hash, "ctime": source.ctime, "baseDir": source.getDirPath(), "ctimePretty": null, "files": files};
+			return {"hash": source.hash, "ctime": source.ctime, "baseDir": source.getDirPath(), "complete": source.complete, "ctimePretty": null, "files": files};
 		});
 	}
 	source(stone, value) {
@@ -136,7 +139,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			}));
 		};
 		return Promise.all(_g1).then(function (data) {
-			return new Source(data, value.hash, stone, value.ctime);
+			return new Source(data, value.hash, stone, value.ctime, (value.complete != null) ? value.complete : true);
 		}, function (rejected) {
 			if (rejected == "Invalid.") {
 				return null;
@@ -227,47 +230,142 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 	getDirFor(value) {
 		return value.baseDir;
 	}
-	flush() {
-		if (this.flushQueued) {
-			return;
-		};
-		this.flushQueued = true;
+	hasSourceId(value, sourceId) {
+		return Lambda.exists(value.files, function (f) {
+			return f.id == sourceId;
+		});
+	}
+	mergePartial(stone, existing, addition, markComplete) {
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = existing.files;
+		while (_g1 < _g2.length) _g.push(_g2[_g1++]);
+		let mergedFiles = _g;
 		let _gthis = this;
-		global.setTimeout(function () {
-			_gthis.flushQueued = false;
-			let db = {};
-			let this1 = _gthis.cache;
-			let _g_keys = this1.keys();
-			while (_g_keys.hasNext()) {
-				let key = _g_keys.next();
-				let _g_value = this1.get(key);
-				let _g = [];
-				let _g1 = 0;
-				while (_g1 < _g_value.length) {
-					let val = _g_value[_g1];
-					++_g1;
-					let tmp = SourceHash.toHex(val.hash);
-					let val1 = val.ctime;
-					let tmp1 = HxOverrides.dateStr(new Date(val.ctime * 1000));
-					let tmp2 = Path.posix.join(".", "./", ".", val.baseDir);
-					let _g2 = [];
-					let _g3 = 0;
-					let _g4 = val.files;
-					while (_g3 < _g4.length) {
-						let file = _g4[_g3];
-						++_g3;
-						_g2.push({"fileHash": SourceHash.toHex(file.fileHash), "filePath": Path.posix.join(".", "./", ".", file.filePath), "id": Path.posix.join(".", "./", ".", file.id), "mtime": file.mtime, "size": file.size});
+		if (addition != null) {
+			return this.value(addition).then(function (addVal) {
+				let _g = 0;
+				let _g1 = addVal.files;
+				while (_g < _g1.length) {
+					let newFile = _g1[_g];
+					++_g;
+					let replaced = false;
+					let _g2 = 0;
+					let _g3 = mergedFiles.length;
+					while (_g2 < _g3) {
+						let i = _g2++;
+						if (mergedFiles[i].id == newFile.id) {
+							mergedFiles[i] = newFile;
+							replaced = true;
+							break;
+						};
+					};
+					if (!replaced) {
+						mergedFiles.push(newFile);
 					};
-					_g.push({"hash": tmp, "ctime": val1, "ctimePretty": tmp1, "baseDir": tmp2, "files": _g2});
 				};
-				db[key] = _g;
+				let merged = {"hash": existing.hash, "ctime": existing.ctime, "baseDir": existing.baseDir, "complete": markComplete, "files": mergedFiles};
+				let this1 = _gthis.cache;
+				let key = _gthis.key(stone);
+				let values = this1.inst.get(key);
+				let idx = values.indexOf(existing);
+				if (idx >= 0) {
+					values[idx] = merged;
+				};
+				_gthis.flush();
+				return merged;
+			});
+		} else {
+			let merged = {"hash": existing.hash, "ctime": existing.ctime, "baseDir": existing.baseDir, "complete": markComplete, "files": mergedFiles};
+			let this1 = this.cache;
+			let key = this.key(stone);
+			let values = this1.inst.get(key);
+			let idx = values.indexOf(existing);
+			if (idx >= 0) {
+				values[idx] = merged;
 			};
-			Utils.saveContent(_gthis.dbFile, JSON.stringify(db, null, "\t")).then(function (_) {
-				Log.log(10, ...["FileCache DB saved."]);
-			}, function (err) {
-				Log.log(50, ...["FileCache DB save error.", err]);
+			this.flush();
+			return Promise.resolve(merged);
+		};
+	}
+	replaceEntry(stone, existing, replacement) {
+		let _gthis = this;
+		return this.value(replacement).then(function (newVal) {
+			let this1 = _gthis.cache;
+			let key = _gthis.key(stone);
+			let values = this1.inst.get(key);
+			let idx = values.indexOf(existing);
+			if (idx >= 0) {
+				values[idx] = newVal;
+			};
+			_gthis.flush();
+			return newVal;
+		});
+	}
+	flush() {
+		let _gthis = this;
+		if (this.flushPromise == null) {
+			this.flushPromise = new Promise(function (res, _) {
+				_gthis.flushResolve = res;
 			});
-		}, 100);
+		};
+		if (this.flushTimerId == null) {
+			this.flushTimerId = global.setTimeout(Register.bind(this, this.doFlush), 100);
+		};
+		return this.flushPromise;
+	}
+	doFlush() {
+		this.flushTimerId = null;
+		let resolve = this.flushResolve;
+		this.flushPromise = null;
+		this.flushResolve = null;
+		let db = {};
+		let this1 = this.cache;
+		let _g_keys = this1.keys();
+		while (_g_keys.hasNext()) {
+			let key = _g_keys.next();
+			let _g_value = this1.get(key);
+			let _g = [];
+			let _g1 = 0;
+			while (_g1 < _g_value.length) {
+				let val = _g_value[_g1];
+				++_g1;
+				let tmp = SourceHash.toHex(val.hash);
+				let val1 = val.ctime;
+				let tmp1 = HxOverrides.dateStr(new Date(val.ctime * 1000));
+				let tmp2 = Path.posix.join(".", "./", ".", val.baseDir);
+				let val2 = val.complete;
+				let _g2 = [];
+				let _g3 = 0;
+				let _g4 = val.files;
+				while (_g3 < _g4.length) {
+					let file = _g4[_g3];
+					++_g3;
+					_g2.push({"fileHash": SourceHash.toHex(file.fileHash), "filePath": Path.posix.join(".", "./", ".", file.filePath), "id": Path.posix.join(".", "./", ".", file.id), "mtime": file.mtime, "size": file.size});
+				};
+				_g.push({"hash": tmp, "ctime": val1, "ctimePretty": tmp1, "baseDir": tmp2, "complete": val2, "files": _g2});
+			};
+			db[key] = _g;
+		};
+		Utils.saveContent(this.dbFile, JSON.stringify(db, null, "\t")).then(function (_) {
+			Log.log(10, ...["FileCache DB saved."]);
+			resolve(null);
+		}, function (err) {
+			Log.log(50, ...["FileCache DB save error.", err]);
+			resolve(null);
+		});
+	}
+	close() {
+		if (this.flushTimerId != null) {
+			global.clearTimeout(this.flushTimerId);
+			this.flushTimerId = null;
+		};
+		if (this.flushResolve != null) {
+			let p = this.flushPromise;
+			this.doFlush();
+			return p;
+		};
+		return Promise.resolve(null);
 	}
 	static get __name__() {
 		return "whet.cache.FileCache"
@@ -279,4 +377,8 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 		return FileCache
 	}
 }
+FileCache.prototype.dbFile = null;
+FileCache.prototype.flushTimerId = null;
+FileCache.prototype.flushResolve = null;
+FileCache.prototype.flushPromise = null;
 

package/bin/whet/cache/HashCache.js

@@ -11,7 +11,7 @@ const $global = Register.$global
 */
 export const HashCache = Register.global("$hxClasses")["whet.cache.HashCache"] = 
 class HashCache extends Register.inherits() {
-	new() {
+	[Register.new]() {
 		this.cache = new StringMap();
 	}
 	
@@ -76,4 +76,5 @@ class HashCache extends Register.inherits() {
 		return HashCache
 	}
 }
+HashCache.prototype.cache = null;
 

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

@@ -9,4 +9,7 @@ export declare class MemoryCache extends BaseCache<AnyStone, Source> {
 	protected source(stone: AnyStone, value: Source): Promise<Source>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected getDirFor(value: Source): string
+	protected hasSourceId(value: Source, sourceId: string): boolean
+	protected mergePartial(stone: AnyStone, existing: Source, addition: Source, markComplete: boolean): Promise<Source>
+	protected replaceEntry(stone: AnyStone, existing: Source, replacement: Source): Promise<Source>
 }

package/bin/whet/cache/MemoryCache.js

@@ -1,13 +1,15 @@
 import {BaseCache} from "./BaseCache.js"
+import {Source} from "../Source.js"
 import {ObjectMap} from "../../haxe/ds/ObjectMap.js"
 import {Register} from "../../genes/Register.js"
+import {Lambda} from "../../Lambda.js"
 
 const $global = Register.$global
 
 export const MemoryCache = Register.global("$hxClasses")["whet.cache.MemoryCache"] = 
 class MemoryCache extends Register.inherits(() => BaseCache, true) {
-	new(rootDir) {
-		super.new(rootDir, new ObjectMap());
+	[Register.new](rootDir) {
+		super[Register.new](rootDir, new ObjectMap());
 	}
 	key(stone) {
 		return stone;
@@ -45,6 +47,55 @@ class MemoryCache extends Register.inherits(() => BaseCache, true) {
 	getDirFor(value) {
 		return value.tryDirPath();
 	}
+	hasSourceId(value, sourceId) {
+		return Lambda.exists(value.data, function (d) {
+			return d.id == sourceId;
+		});
+	}
+	mergePartial(stone, existing, addition, markComplete) {
+		let mergedData = existing.data.slice();
+		if (addition != null) {
+			let _g = 0;
+			let _g1 = addition.data;
+			while (_g < _g1.length) {
+				let newItem = _g1[_g];
+				++_g;
+				let replaced = false;
+				let _g2 = 0;
+				let _g3 = mergedData.length;
+				while (_g2 < _g3) {
+					let i = _g2++;
+					if (mergedData[i].id == newItem.id) {
+						mergedData[i] = newItem;
+						replaced = true;
+						break;
+					};
+				};
+				if (!replaced) {
+					mergedData.push(newItem);
+				};
+			};
+		};
+		let merged = new Source(mergedData, existing.hash, stone, existing.ctime, markComplete);
+		let this1 = this.cache;
+		let key = this.key(stone);
+		let values = this1.inst.get(key);
+		let idx = values.indexOf(existing);
+		if (idx >= 0) {
+			values[idx] = merged;
+		};
+		return Promise.resolve(merged);
+	}
+	replaceEntry(stone, existing, replacement) {
+		let this1 = this.cache;
+		let key = this.key(stone);
+		let values = this1.inst.get(key);
+		let idx = values.indexOf(existing);
+		if (idx >= 0) {
+			values[idx] = replacement;
+		};
+		return Promise.resolve(replacement);
+	}
 	static get __name__() {
 		return "whet.cache.MemoryCache"
 	}

package/bin/whet/magic/MinimatchType.d.ts

@@ -1,4 +1,4 @@
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
 
 export type MinimatchType = Minimatch | string
 

package/bin/whet/magic/MinimatchType.js

@@ -1,4 +1,4 @@
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
 import {Register} from "../../genes/Register.js"
 
 const $global = Register.$global
@@ -7,8 +7,8 @@ export const MinimatchType_Fields_ = Register.global("$hxClasses")["whet.magic._
 class MinimatchType_Fields_ {
 	static makeMinimatch(src) {
 		if (typeof(src) == "string") {
-			return new Minimatch.Minimatch(src, null);
-		} else if (src instanceof Minimatch.Minimatch) {
+			return new Minimatch(src);
+		} else if (src instanceof Minimatch) {
 			return src;
 		} else {
 			throw new Error("Expected a string or Minimatch object.");

package/bin/whet/magic/RoutePathType.js

@@ -2,7 +2,7 @@ import {Files} from "../stones/Files.js"
 import {Router} from "../route/Router.js"
 import {MinimatchType_Fields_} from "./MinimatchType.js"
 import {Stone} from "../Stone.js"
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
 import {Register} from "../../genes/Register.js"
 
 const $global = Register.$global

package/bin/whet/route/OutputFilterMatcher.js

@@ -1,4 +1,4 @@
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
 import {Register} from "../../genes/Register.js"
 
 const $global = Register.$global
@@ -31,7 +31,7 @@ class OutputFilterMatcher {
 		if (!queryIsPattern && filter.patterns != null) {
 			let _g = 0;
 			let _g1 = filter.patterns;
-			while (_g < _g1.length) if (new Minimatch.Minimatch("**/" + _g1[_g++], null).match(query)) {
+			while (_g < _g1.length) if (new Minimatch("**/" + _g1[_g++]).match(query)) {
 				return true;
 			};
 			return false;

package/bin/whet/route/RouteResult.d.ts

@@ -1,5 +1,6 @@
 import {AnyStone} from "../Stone"
 import {SourceData} from "../Source"
+import {Buffer} from "buffer"
 
 export declare class RouteResult {
 	constructor(serveId: string, sourceId: string, source: AnyStone)
@@ -19,4 +20,19 @@ export declare class RouteResult {
 	*/
 	source: AnyStone
 	get(): Promise<SourceData>
+	
+	/**
+	Get the raw Buffer directly.
+	*/
+	getData(): Promise<Buffer>
+	
+	/**
+	Get the output as a UTF-8 string.
+	*/
+	getString(): Promise<string>
+	
+	/**
+	Get the output parsed as JSON.
+	*/
+	getJson(): Promise<any>
 }

package/bin/whet/route/RouteResult.js

@@ -4,15 +4,45 @@ const $global = Register.$global
 
 export const RouteResult = Register.global("$hxClasses")["whet.route.RouteResult"] = 
 class RouteResult extends Register.inherits() {
-	new(serveId, sourceId, source) {
+	[Register.new](serveId, sourceId, source) {
 		this.serveId = serveId;
 		this.sourceId = sourceId;
 		this.source = source;
 	}
 	get() {
-		let _gthis = this;
-		return this.source.getSource().then(function (data) {
-			return data.get(_gthis.sourceId);
+		return this.source.getPartialSource(this.sourceId).then(function (s) {
+			if (s != null) {
+				return s.get();
+			} else {
+				return null;
+			};
+		});
+	}
+	
+	/**
+	Get the raw Buffer directly.
+	*/
+	getData() {
+		return this.get().then(function (sd) {
+			return sd.data;
+		});
+	}
+	
+	/**
+	Get the output as a UTF-8 string.
+	*/
+	getString() {
+		return this.getData().then(function (d) {
+			return d.toString("utf-8");
+		});
+	}
+	
+	/**
+	Get the output parsed as JSON.
+	*/
+	getJson() {
+		return this.getString().then(function (s) {
+			return JSON.parse(s);
 		});
 	}
 	static get __name__() {
@@ -22,4 +52,7 @@ class RouteResult extends Register.inherits() {
 		return RouteResult
 	}
 }
+RouteResult.prototype.serveId = null;
+RouteResult.prototype.sourceId = null;
+RouteResult.prototype.source = null;
 

package/bin/whet/route/Router.d.ts

@@ -3,7 +3,8 @@ import {RoutePathType} from "../magic/RoutePathType"
 import {MinimatchType} from "../magic/MinimatchType"
 import {OutputFilter, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
-import Minimatch from "minimatch"
+import {Minimatch} from "minimatch"
+import {Buffer} from "buffer"
 
 export declare class Router {
 	constructor(routes?: null | RoutePathType)
@@ -27,6 +28,21 @@ export declare class Router {
 	* Save files filtered by `pattern` into provided `saveInto` folder.
 	*/
 	saveInto(pattern: MinimatchType, saveInto: string, clearFirst?: boolean): Promise<any>
+	
+	/**
+	Get the raw Buffer of the first matching result.
+	*/
+	getData(pattern?: null | MinimatchType): Promise<Buffer>
+	
+	/**
+	Get the first matching result as a UTF-8 string.
+	*/
+	getString(pattern?: null | MinimatchType): Promise<string>
+	
+	/**
+	Get the first matching result parsed as JSON.
+	*/
+	getJson(pattern?: null | MinimatchType): Promise<any>
 	listContents(pattern?: null | MinimatchType): Promise<string>
 	
 	/**
@@ -44,6 +60,11 @@ export type Filter = {
 }
 
 export declare class Filters {
+	
+	/**
+	Like finalize, but restores filter state afterwards. Returns serveId on match, null otherwise.
+	*/
+	static tryFinalize($this: Filter[], finalPath: string): null | string
 	protected static isPathPossible($this: Filter[], f: Filter): boolean
 }