whet 0.0.34 → 0.1.1

package/bin/whet/ConfigStore.js

@@ -0,0 +1,342 @@
+import {Router} from "./route/Router.js"
+import {Utils} from "./Utils.js"
+import {Stone} from "./Stone.js"
+import * as Path from "path"
+import {Register} from "../genes/Register.js"
+import * as Fs from "fs"
+import {Reflect as Reflect__1} from "../Reflect.js"
+
+const $global = Register.$global
+
+export const ConfigStore = Register.global("$hxClasses")["whet.ConfigStore"] = 
+class ConfigStore extends Register.inherits() {
+	[Register.new](path) {
+		this.appliedPatches = new WeakMap();
+		this.baselines = new WeakMap();
+		this.loadPromise = null;
+		this.size = null;
+		this.mtimeMs = null;
+		this.persistedData = null;
+		this.data = null;
+		this.path = path;
+	}
+	ensureApplied(stone) {
+		let _gthis = this;
+		return this.reload().then(function (_) {
+			if (!_gthis.baselines.has(stone)) {
+				_gthis.captureBaseline(stone);
+			};
+			let entry = _gthis.getEntry(stone);
+			let lastApplied = _gthis.appliedPatches.get(stone);
+			if (entry == lastApplied) {
+				return null;
+			};
+			if (entry != null && lastApplied != null && JSON.stringify(entry) == JSON.stringify(lastApplied)) {
+				return null;
+			};
+			_gthis.applyPatch(stone);
+			return null;
+		});
+	}
+	setPatch(stone, patch) {
+		let _gthis = this;
+		return this.reload().then(function (_) {
+			if (_gthis.data == null) {
+				_gthis.data = {};
+			};
+			_gthis.data[stone.id] = patch;
+			return _gthis.writeFile();
+		}).then(function (_) {
+			_gthis.applyPatch(stone);
+			return null;
+		});
+	}
+	getEntryById(stoneId) {
+		if (this.data == null) {
+			return null;
+		};
+		return this.data[stoneId];
+	}
+	setEntry(stoneId, patch) {
+		if (this.data == null) {
+			this.data = {};
+		};
+		this.data[stoneId] = patch;
+	}
+	clearEntry(stoneId) {
+		if (this.data == null) {
+			return;
+		};
+		if (this.persistedData != null && Object.prototype.hasOwnProperty.call(this.persistedData, stoneId)) {
+			this.data[stoneId] = ConfigStore.deepClone(this.persistedData[stoneId]);
+		} else {
+			Reflect__1.deleteField(this.data, stoneId);
+		};
+	}
+	flush() {
+		return this.writeFile();
+	}
+	isDirty(stoneId) {
+		if (stoneId != null) {
+			let current = (this.data != null) ? this.data[stoneId] : null;
+			let persisted = (this.persistedData != null) ? this.persistedData[stoneId] : null;
+			if (current == persisted) {
+				return false;
+			};
+			if (current == null || persisted == null) {
+				return true;
+			};
+			return JSON.stringify(current) != JSON.stringify(persisted);
+		};
+		return ((this.data != null) ? JSON.stringify(this.data) : "{}") != ((this.persistedData != null) ? JSON.stringify(this.persistedData) : "{}");
+	}
+	reload() {
+		if (this.loadPromise != null) {
+			return this.loadPromise;
+		};
+		let _gthis = this;
+		this.loadPromise = this.doReload().then(function (result) {
+			_gthis.loadPromise = null;
+			return result;
+		})["catch"](function (e) {
+			_gthis.loadPromise = null;
+			return Promise.reject(e);
+		});
+		return this.loadPromise;
+	}
+	doReload() {
+		let _gthis = this;
+		return this.statFile().then(function (stats) {
+			if (stats == null) {
+				if (_gthis.data == null) {
+					_gthis.data = {};
+					_gthis.persistedData = {};
+				};
+				return Promise.resolve(null);
+			};
+			let newMtime = stats.mtimeMs;
+			let newSize = stats.size;
+			if (newMtime == _gthis.mtimeMs && newSize == _gthis.size) {
+				return Promise.resolve(null);
+			};
+			return _gthis.readAndParse().then(function (_) {
+				_gthis.mtimeMs = newMtime;
+				_gthis.size = newSize;
+				return null;
+			});
+		});
+	}
+	statFile() {
+		let _gthis = this;
+		return new Promise(function (res, rej) {
+			Fs.stat(_gthis.path, function (err, stats) {
+				if (err != null) {
+					let code = err.code;
+					if (code == "ENOENT") {
+						res(null);
+					} else {
+						rej(err);
+					};
+				} else {
+					res(stats);
+				};
+			});
+		});
+	}
+	readAndParse() {
+		let _gthis = this;
+		return new Promise(function (res, rej) {
+			Fs.readFile(_gthis.path, {"encoding": "utf-8"}, function (err, content) {
+				if (err != null) {
+					rej(err);
+				} else {
+					_gthis.data = JSON.parse(content);
+					_gthis.persistedData = ConfigStore.deepClone(_gthis.data);
+					res(null);
+				};
+			});
+		});
+	}
+	writeFile() {
+		let _gthis = this;
+		return Utils.ensureDirExist(Path.dirname(this.path)).then(function (_) {
+			let content = JSON.stringify(_gthis.data, null, "  ");
+			return new Promise(function (res, rej) {
+				Fs.writeFile(_gthis.path, content, function (err) {
+					if (err != null) {
+						rej(err);
+					} else {
+						Fs.stat(_gthis.path, function (err, stats) {
+							if (err != null) {
+								rej(err);
+							} else {
+								_gthis.mtimeMs = stats.mtimeMs;
+								_gthis.size = stats.size;
+								_gthis.persistedData = ConfigStore.deepClone(_gthis.data);
+								res(null);
+							};
+						});
+					};
+				});
+			});
+		});
+	}
+	getEntry(stone) {
+		if (this.data == null) {
+			return null;
+		};
+		return this.data[stone.id];
+	}
+	captureBaseline(stone) {
+		let baseline = {};
+		let configObj = stone.config;
+		let _g_keys = Reflect__1.fields(configObj);
+		let _g_index = 0;
+		while (_g_index < _g_keys.length) {
+			let key = _g_keys[_g_index++];
+			let _g_value = configObj[key];
+			if (ConfigStore.BASE_CONFIG_KEYS.includes(key)) {
+				continue;
+			};
+			if (ConfigStore.isJsonSerializable(_g_value)) {
+				baseline[key] = ConfigStore.deepClone(_g_value);
+			};
+		};
+		this.baselines.set(stone, baseline);
+	}
+	applyPatch(stone) {
+		let baseline = this.baselines.get(stone);
+		if (baseline == null) {
+			return;
+		};
+		let entry = this.getEntry(stone);
+		let configObj = stone.config;
+		let _g_keys = Reflect__1.fields(baseline);
+		let _g_index = 0;
+		while (_g_index < _g_keys.length) {
+			let key = _g_keys[_g_index++];
+			let _g_value = baseline[key];
+			if (entry != null && Object.prototype.hasOwnProperty.call(entry, key)) {
+				configObj[key] = ConfigStore.deepMerge(ConfigStore.deepClone(_g_value), entry[key]);
+			} else {
+				configObj[key] = ConfigStore.deepClone(_g_value);
+			};
+		};
+		if (entry != null) {
+			let _g_keys = Reflect__1.fields(entry);
+			let _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				let key = _g_keys[_g_index++];
+				let _g_value = entry[key];
+				if (!Object.prototype.hasOwnProperty.call(baseline, key)) {
+					configObj[key] = ConfigStore.deepClone(_g_value);
+				};
+			};
+		};
+		let prevApplied = this.appliedPatches.get(stone);
+		if (prevApplied != null) {
+			let _g_keys = Reflect__1.fields(prevApplied);
+			let _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				let key = _g_keys[_g_index++];
+				if (!Object.prototype.hasOwnProperty.call(baseline, key) && (entry == null || !Object.prototype.hasOwnProperty.call(entry, key))) {
+					Reflect__1.deleteField(configObj, key);
+				};
+			};
+		};
+		this.appliedPatches.set(stone, (entry != null) ? ConfigStore.deepClone(entry) : null);
+	}
+	static isJsonSerializable(val) {
+		if (val == null) {
+			return true;
+		};
+		if (((val) instanceof Stone)) {
+			return false;
+		};
+		if (((val) instanceof Router)) {
+			return false;
+		};
+		if (typeof val === "function") {
+			return false;
+		};
+		return true;
+	}
+	static deepClone(val) {
+		if (val == null) {
+			return null;
+		};
+		if (!ConfigStore.isJsonSerializable(val)) {
+			return null;
+		};
+		if (((val) instanceof Array)) {
+			let arr = val;
+			let result = new Array(arr.length);
+			let _g = 0;
+			let _g1 = arr.length;
+			while (_g < _g1) {
+				let i = _g++;
+				result[i] = ConfigStore.deepClone(arr[i]);
+			};
+			return result;
+		};
+		if (typeof val === "object") {
+			let obj = val;
+			let result = {};
+			let _g_keys = Reflect__1.fields(obj);
+			let _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				let key = _g_keys[_g_index++];
+				result[key] = ConfigStore.deepClone(obj[key]);
+			};
+			return result;
+		};
+		return val;
+	}
+	static deepMerge(base, patch) {
+		if (patch == null) {
+			return null;
+		};
+		if (base == null) {
+			return ConfigStore.deepClone(patch);
+		};
+		if (((patch) instanceof Array)) {
+			return ConfigStore.deepClone(patch);
+		};
+		if (typeof patch === "object" && typeof base === "object" && !((base) instanceof Array)) {
+			let baseObj = base;
+			let patchObj = patch;
+			let result = {};
+			let _g_keys = Reflect__1.fields(baseObj);
+			let _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				let key = _g_keys[_g_index++];
+				result[key] = baseObj[key];
+			};
+			let _g_keys1 = Reflect__1.fields(patchObj);
+			let _g_index1 = 0;
+			while (_g_index1 < _g_keys1.length) {
+				let key = _g_keys1[_g_index1++];
+				result[key] = ConfigStore.deepMerge(result[key], patchObj[key]);
+			};
+			return result;
+		};
+		return ConfigStore.deepClone(patch);
+	}
+	static get __name__() {
+		return "whet.ConfigStore"
+	}
+	get __class__() {
+		return ConfigStore
+	}
+}
+ConfigStore.prototype.path = null;
+ConfigStore.prototype.data = null;
+ConfigStore.prototype.persistedData = null;
+ConfigStore.prototype.mtimeMs = null;
+ConfigStore.prototype.size = null;
+ConfigStore.prototype.loadPromise = null;
+ConfigStore.prototype.baselines = null;
+ConfigStore.prototype.appliedPatches = null;
+
+
+ConfigStore.BASE_CONFIG_KEYS = ["cacheStrategy", "id", "project", "dependencies", "configStore"]

package/bin/whet/Project.d.ts

@@ -1,5 +1,8 @@
 import {CacheManager} from "./cache/CacheManager"
-import {AnyStone} from "./Stone"
+import {CacheStrategy} from "./cache/Cache"
+import {AnyStone, OutputFilter} from "./Stone"
+import {Source} from "./Source"
+import {ConfigStore} from "./ConfigStore"
 import {Option, Command} from "commander"
 
 export declare class Project {
@@ -9,6 +12,7 @@ export declare class Project {
 	description: string
 	rootDir: string
 	cache: CacheManager
+	configStore: ConfigStore
 	stones: AnyStone[]
 	onInit: (config: any) => Promise<any>
 	
@@ -17,13 +21,26 @@ export declare class Project {
 	*/
 	config: any
 	protected options: Option[]
+	getStone(id: string): null | AnyStone
+	describeStones(): StoneDescription[]
+	listStoneOutputs(id: string): Promise<null | string[]>
+	getStoneSource(id: string, sourceId?: null | string): Promise<null | Source>
+	refreshStoneSource(id: string): Promise<null | Source>
+	getStoneConfig(id: string): Promise<null | StoneConfigView>
+	setStoneConfig(id: string, patch: any, mode: string): Promise<boolean>
+	clearStoneConfigPreview(id: string): Promise<boolean>
 	addCommand(name: string, stone?: null | AnyStone): Command
+	protected isCommandNameTaken(name: string): boolean
 	toString(): string
 	protected static projects: Project[]
 }
 
 export type ProjectConfig = {
 	cache?: null | CacheManager, 
+	/**
+	Project-level ConfigStore, applies to any stone without an explicit configStore.
+	*/
+	configStore?: null | ConfigStore, 
 	description?: null | string, 
 	id?: null | string, 
 	name: string, 
@@ -31,11 +48,31 @@ export type ProjectConfig = {
 	* 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. Use `addOption` to get Option instance.
-	*/
 	options?: null | Option[], 
 	rootDir?: null | string
 }
 
+export type StoneDescription = {
+	cacheStrategy?: null | CacheStrategy, 
+	className: string, 
+	id: string, 
+	outputFilter?: null | OutputFilter
+}
+
+export type StoneConfigView = {
+	editable: any, 
+	fixed: any, 
+	id: string, 
+	meta: StoneConfigMeta
+}
+
+export type StoneConfigMeta = {
+	cacheStrategy: CacheStrategy, 
+	className: string, 
+	dependencyIds: string[], 
+	hasProjectConfigStore: boolean, 
+	hasStoneConfigStore: boolean, 
+	uiHints?: null | any
+}
+
 export const addOption: (flags: string, description: null | string) => Option

package/bin/whet/Project.js

@@ -1,17 +1,24 @@
+import {Router} from "./route/Router.js"
+import {StoneId_Fields_} from "./magic/StoneId.js"
+import {MaybeArray_Fields_} from "./magic/MaybeArray.js"
 import {CacheManager} from "./cache/CacheManager.js"
 import {Whet_Fields_} from "./Whet.js"
+import {Stone} from "./Stone.js"
 import {Log} from "./Log.js"
+import {ConfigStore} from "./ConfigStore.js"
 import * as Path from "path"
 import {Register} from "../genes/Register.js"
 import {Command, Option} from "commander"
 import {StringTools} from "../StringTools.js"
+import {Reflect as Reflect__1} from "../Reflect.js"
 
 const $global = Register.$global
 
 export const Project = Register.global("$hxClasses")["whet.Project"] = 
 class Project extends Register.inherits() {
-	new(config) {
+	[Register.new](config) {
 		this.stones = [];
+		this.configStore = null;
 		this.cache = null;
 		Log.log(20, ...["Instantiating new Project."]);
 		if (config == null || config.name == null) {
@@ -46,18 +53,189 @@ class Project extends Register.inherits() {
 		} else {
 			this.rootDir = config.rootDir;
 		};
+		this.configStore = config.configStore;
 		this.cache = (config.cache == null) ? new CacheManager(this) : config.cache;
 		Project.projects.push(this);
 		Log.log(30, ...["New project created.", {"project": this, "projectCount": Project.projects.length}]);
 	}
+	getStone(id) {
+		let _g = 0;
+		let _g1 = this.stones;
+		while (_g < _g1.length) {
+			let stone = _g1[_g];
+			++_g;
+			if (stone.id == id) {
+				return stone;
+			};
+		};
+		return null;
+	}
+	describeStones() {
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = this.stones;
+		while (_g1 < _g2.length) {
+			let stone = _g2[_g1];
+			++_g1;
+			_g.push({"id": stone.id, "className": StoneId_Fields_.getTypeName(stone), "outputFilter": stone.getOutputFilter(), "cacheStrategy": stone.cacheStrategy});
+		};
+		return _g;
+	}
+	listStoneOutputs(id) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(null);
+		} else {
+			return stone.listIds();
+		};
+	}
+	getStoneSource(id, sourceId) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(null);
+		} else if (sourceId != null) {
+			return stone.getPartialSource(sourceId);
+		} else {
+			return stone.getSource();
+		};
+	}
+	refreshStoneSource(id) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(null);
+		} else {
+			return this.cache.refreshSource(stone);
+		};
+	}
+	getStoneConfig(id) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(null);
+		};
+		let tmp = stone.config.configStore;
+		let store = (tmp != null) ? tmp : this.configStore;
+		let init = (store != null) ? store.ensureApplied(stone) : Promise.resolve(null);
+		let _gthis = this;
+		return init.then(function (_) {
+			let editable = {};
+			let configObj = stone.config;
+			let _g_keys = Reflect__1.fields(configObj);
+			let _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				let key = _g_keys[_g_index++];
+				let _g_value = configObj[key];
+				if (ConfigStore.BASE_CONFIG_KEYS.includes(key)) {
+					continue;
+				};
+				if (ConfigStore.isJsonSerializable(_g_value)) {
+					editable[key] = ConfigStore.deepClone(_g_value);
+				};
+			};
+			let depIds = [];
+			if (stone.config.dependencies != null) {
+				let deps = MaybeArray_Fields_.makeArray(stone.config.dependencies);
+				let _g = [];
+				let _g1 = 0;
+				while (_g1 < deps.length) _g.push(deps[_g1++].id);
+				depIds = _g;
+			};
+			let fixed = {};
+			let _g_keys1 = Reflect__1.fields(configObj);
+			let _g_index1 = 0;
+			while (_g_index1 < _g_keys1.length) {
+				let key = _g_keys1[_g_index1++];
+				let _g_value = configObj[key];
+				if (ConfigStore.BASE_CONFIG_KEYS.includes(key)) {
+					continue;
+				};
+				if (ConfigStore.isJsonSerializable(_g_value)) {
+					continue;
+				};
+				if (((_g_value) instanceof Stone)) {
+					fixed[key] = {"type": "stone", "stoneId": _g_value.id};
+				} else if (((_g_value) instanceof Router)) {
+					fixed[key] = {"type": "stones", "stoneIds": _g_value.collectStoneIds()};
+				} else if (((_g_value) instanceof Array)) {
+					let arr = _g_value;
+					if (arr.length > 0 && ((arr[0]) instanceof Stone)) {
+						let _g = [];
+						let _g1 = 0;
+						let _g2 = arr;
+						while (_g1 < _g2.length) _g.push(_g2[_g1++].id);
+						fixed[key] = {"type": "stones", "stoneIds": _g};
+					};
+				};
+			};
+			return {"id": stone.id, "editable": editable, "fixed": fixed, "meta": {"className": StoneId_Fields_.getTypeName(stone), "cacheStrategy": stone.cacheStrategy, "dependencyIds": depIds, "hasStoneConfigStore": stone.config.configStore != null, "hasProjectConfigStore": _gthis.configStore != null}};
+		});
+	}
+	setStoneConfig(id, patch, mode) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(false);
+		};
+		let tmp = stone.config.configStore;
+		let store = (tmp != null) ? tmp : this.configStore;
+		if (store == null) {
+			return Promise.resolve(false);
+		};
+		store.setEntry(stone.id, patch);
+		if (mode == "persist") {
+			return store.flush().then(function (_) {
+				return true;
+			});
+		} else {
+			return Promise.resolve(true);
+		};
+	}
+	clearStoneConfigPreview(id) {
+		let stone = this.getStone(id);
+		if (stone == null) {
+			return Promise.resolve(false);
+		};
+		let tmp = stone.config.configStore;
+		let store = (tmp != null) ? tmp : this.configStore;
+		if (store == null) {
+			return Promise.resolve(false);
+		};
+		store.clearEntry(stone.id);
+		return Promise.resolve(true);
+	}
 	addCommand(name, stone) {
-		let cmd = new Command(name);
+		let cmdName = name;
+		let cmdAlias = null;
 		if (stone != null) {
-			cmd.alias(stone.id + "." + cmd.name());
+			let alias = stone.id + "." + name;
+			if (this.isCommandNameTaken(name)) {
+				cmdName = alias;
+			} else {
+				cmdAlias = alias;
+			};
+		};
+		let cmd = new Command(cmdName);
+		if (cmdAlias != null) {
+			cmd.alias(cmdAlias);
 		};
 		Whet_Fields_.program.addCommand(cmd);
 		return cmd;
 	}
+	isCommandNameTaken(name) {
+		let _g = 0;
+		let _g1 = Whet_Fields_.program.commands;
+		while (_g < _g1.length) {
+			let cmd = _g1[_g];
+			++_g;
+			if (cmd.name() == name) {
+				return true;
+			};
+			let _g2 = 0;
+			let _g3 = cmd.aliases();
+			while (_g2 < _g3.length) if (_g3[_g2++] == name) {
+				return true;
+			};
+		};
+		return false;
+	}
 	toString() {
 		return "" + this.name + "@" + this.rootDir;
 	}
@@ -68,6 +246,16 @@ class Project extends Register.inherits() {
 		return Project
 	}
 }
+Project.prototype.name = null;
+Project.prototype.id = null;
+Project.prototype.description = null;
+Project.prototype.rootDir = null;
+Project.prototype.cache = null;
+Project.prototype.configStore = null;
+Project.prototype.stones = null;
+Project.prototype.onInit = null;
+Project.prototype.config = null;
+Project.prototype.options = null;
 
 
 Project.projects = []

package/bin/whet/Source.d.ts

@@ -4,12 +4,18 @@ import {SourceHash} from "./SourceHash"
 import {Buffer} from "buffer"
 
 export declare class Source {
-	protected constructor(data: SourceData[], hash: SourceHash, origin: AnyStone, ctime: number)
+	protected constructor(data: SourceData[], hash: SourceHash, origin: AnyStone, ctime: number, complete?: boolean)
 	data: SourceData[]
 	hash: SourceHash
 	origin: AnyStone
 	ctime: number
+	complete: boolean
 	protected dirPath: string
+	
+	/**
+	Filter to a single sourceId. Returns null if sourceId not found.
+	*/
+	filterTo(sourceId: string): null | Source
 	tryDirPath(): null | string
 	
 	/**