whet 0.1.1 → 0.4.0

package/bin/whet/route/Router.js

@@ -2,6 +2,7 @@ import {RouteResult} from "./RouteResult.js"
 import {OutputFilterMatcher} from "./OutputFilterMatcher.js"
 import {RoutePathType_Fields_} from "../magic/RoutePathType.js"
 import {MinimatchType_Fields_} from "../magic/MinimatchType.js"
+import {MemoContext} from "../cache/MemoContext.js"
 import {Utils} from "../Utils.js"
 import {Stone} from "../Stone.js"
 import {SourceHash} from "../SourceHash.js"
@@ -21,6 +22,13 @@ class Router extends Register.inherits() {
 		while (_g < _g1.length) this.routes.push(_g1[_g++]);
 	}
 	
+	/**
+	Remove all routes.
+	*/
+	clearRoutes() {
+		this.routes.length = 0;
+	}
+	
 	/**
 	Recursively collect all Stone IDs referenced in this Router's routes.
 	*/
@@ -56,7 +64,10 @@ class Router extends Register.inherits() {
 	* @param pattern A glob pattern to search for.
 	*/
 	get(pattern) {
-		return this.getResults([{"pathSoFar": [], "filter": (pattern != null) ? MinimatchType_Fields_.makeMinimatch(pattern) : null, "inProgress": true, "remDirs": []}], []);
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			return _gthis.getResults([{"pathSoFar": [], "filter": (pattern != null) ? MinimatchType_Fields_.makeMinimatch(pattern) : null, "inProgress": true, "remDirs": []}], []);
+		});
 	}
 	getResults(mainFilters, results) {
 		let _gthis = this;
@@ -207,45 +218,48 @@ class Router extends Register.inherits() {
 	* Includes matched serveIds in hash to capture filter effects.
 	*/
 	getHash(pattern) {
-		return this.get(pattern).then(function (items) {
-			let uniqueStones = [];
-			let serveIds = [];
-			let _g = 0;
-			while (_g < items.length) {
-				let item = items[_g];
-				++_g;
-				if (uniqueStones.indexOf(item.source) == -1) {
-					uniqueStones.push(item.source);
-				};
-				serveIds.push(item.serveId);
-			};
-			serveIds.sort(function (a, b) {
-				if (a < b) {
-					return -1;
-				} else if (a > b) {
-					return 1;
-				} else {
-					return 0;
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			return _gthis.get(pattern).then(function (items) {
+				let uniqueStones = [];
+				let serveIds = [];
+				let _g = 0;
+				while (_g < items.length) {
+					let item = items[_g];
+					++_g;
+					if (uniqueStones.indexOf(item.source) == -1) {
+						uniqueStones.push(item.source);
+					};
+					serveIds.push(item.serveId);
 				};
-			});
-			let result = new Array(uniqueStones.length);
-			let _g1 = 0;
-			let _g2 = uniqueStones.length;
-			while (_g1 < _g2) {
-				let i = _g1++;
-				result[i] = uniqueStones[i].getHash();
-			};
-			return Promise.all(result).then(function (hashes) {
-				hashes.sort(function (a, b) {
-					if (a.toString() < b.toString()) {
+				serveIds.sort(function (a, b) {
+					if (a < b) {
 						return -1;
-					} else if (a.toString() > b.toString()) {
+					} else if (a > b) {
 						return 1;
 					} else {
 						return 0;
 					};
 				});
-				return SourceHash.merge(...hashes).add(SourceHash.fromString(serveIds.join("\n")));
+				let result = new Array(uniqueStones.length);
+				let _g1 = 0;
+				let _g2 = uniqueStones.length;
+				while (_g1 < _g2) {
+					let i = _g1++;
+					result[i] = uniqueStones[i].getHash();
+				};
+				return Promise.all(result).then(function (hashes) {
+					hashes.sort(function (a, b) {
+						if (a.toString() < b.toString()) {
+							return -1;
+						} else if (a.toString() > b.toString()) {
+							return 1;
+						} else {
+							return 0;
+						};
+					});
+					return SourceHash.merge(...hashes).add(SourceHash.fromString(serveIds.join("\n")));
+				});
 			});
 		});
 	}

package/bin/whet/stones/Files.d.ts

@@ -18,6 +18,11 @@ export declare class Files extends Stone<FilesConfig> {
 		id: string, 
 		pathId: string
 	}
+	
+	/**
+	Reuse an existing Files stone for this path, or create a new one.
+	*/
+	static fromPath(path: string): Files
 }
 
 export type FilesConfig = {

package/bin/whet/stones/Files.js

@@ -5,6 +5,7 @@ import {Stone} from "../Stone.js"
 import {IdUtils, RootDir} from "../SourceId.js"
 import {SourceHash} from "../SourceHash.js"
 import {SourceData} from "../Source.js"
+import {Project} from "../Project.js"
 import {Register} from "../../genes/Register.js"
 
 const $global = Register.$global
@@ -164,6 +165,25 @@ class Files extends Register.inherits(() => Stone, true) {
 		};
 		return {"pathId": pathId, "id": tmp};
 	}
+	
+	/**
+	Reuse an existing Files stone for this path, or create a new one.
+	*/
+	static fromPath(path) {
+		let project = Project.projects[Project.projects.length - 1];
+		if (project != null) {
+			let _g = 0;
+			let _g1 = project.stones;
+			while (_g < _g1.length) {
+				let stone = _g1[_g];
+				++_g;
+				if (stone.id == path && ((stone) instanceof Files)) {
+					return stone;
+				};
+			};
+		};
+		return new Files({"paths": [path]});
+	}
 	static get __name__() {
 		return "whet.stones.Files"
 	}

package/bin/whet/stones/StoneFactory.d.ts

@@ -0,0 +1,55 @@
+import {Router} from "../route/Router"
+import {RoutePathType} from "../magic/RoutePathType"
+import {AnyStone} from "../Stone"
+
+/**
+* Base class for dynamic stone lifecycle management.
+*
+* Manages creation, update, and removal of stones based on external data.
+* Extends Router so it can be used directly as a route source.
+*
+* JS subclasses override `createEntry`, `updateEntry`, and `addBaseRoutes`.
+*/
+export declare class StoneFactory<D, E extends FactoryEntry> extends Router {
+	constructor(routes?: null | RoutePathType)
+	entryMap: Map<string, E>
+	
+	/**
+	* Sync factory state with data. Calls `createEntry` for new keys,
+	* `updateEntry` for existing keys, and removes entries whose keys are absent.
+	* @return Array of removed keys (caller can use for cache cleanup via `cache.clearStone`).
+	*/
+	sync(data: D[], keyFn: ((arg0: D) => string)): string[]
+	
+	/**
+	Override in subclass: create stones and routes for a new data entry.
+	*/
+	protected createEntry(key: string, data: D): E
+	
+	/**
+	* Override in subclass: update an existing entry's stone configs in-place.
+	* Default implementation destroys and recreates the entry.
+	*/
+	protected updateEntry(key: string, data: D, existing: E): void
+	
+	/**
+	Override in subclass: add routes that are present on every sync (e.g., a database JSON file).
+	*/
+	protected addBaseRoutes(): void
+	
+	/**
+	Remove an entry, deregistering its stones from the project.
+	*/
+	removeEntry(key: string): void
+}
+
+export type FactoryEntry = {
+	/**
+	Route definitions for this entry — added to the factory's Router on sync.
+	*/
+	routes?: null | RoutePathType, 
+	/**
+	Stones owned by this entry — deregistered from project on removal.
+	*/
+	stones: AnyStone[]
+}

package/bin/whet/stones/StoneFactory.js

@@ -0,0 +1,116 @@
+import {Router} from "../route/Router.js"
+import {RoutePathType_Fields_} from "../magic/RoutePathType.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+* Base class for dynamic stone lifecycle management.
+*
+* Manages creation, update, and removal of stones based on external data.
+* Extends Router so it can be used directly as a route source.
+*
+* JS subclasses override `createEntry`, `updateEntry`, and `addBaseRoutes`.
+*/
+export const StoneFactory = Register.global("$hxClasses")["whet.stones.StoneFactory"] = 
+class StoneFactory extends Register.inherits(Router) {
+	[Register.new](routes) {
+		this.entryMap = new Map();
+		super[Register.new](routes);
+	}
+	
+	/**
+	* Sync factory state with data. Calls `createEntry` for new keys,
+	* `updateEntry` for existing keys, and removes entries whose keys are absent.
+	* @return Array of removed keys (caller can use for cache cleanup via `cache.clearStone`).
+	*/
+	sync(data, keyFn) {
+		let newKeys = new Set();
+		this.clearRoutes();
+		this.addBaseRoutes();
+		let _g = 0;
+		while (_g < data.length) {
+			let item = data[_g];
+			++_g;
+			let key = keyFn(item);
+			newKeys.add(key);
+			if (this.entryMap.has(key)) {
+				this.updateEntry(key, item, this.entryMap.get(key));
+			} else {
+				this.entryMap.set(key, this.createEntry(key, item));
+			};
+			let entry = this.entryMap.get(key);
+			if (entry.routes != null) {
+				let _g = 0;
+				let _g1 = RoutePathType_Fields_.makeRoutePath(entry.routes);
+				while (_g < _g1.length) this.routes.push(_g1[_g++]);
+			};
+		};
+		let toRemove = [];
+		let jsIterator = this.entryMap.keys();
+		let _g_lastStep = jsIterator.next();
+		while (!_g_lastStep.done) {
+			let v = _g_lastStep.value;
+			_g_lastStep = jsIterator.next();
+			if (!newKeys.has(v)) {
+				toRemove.push(v);
+			};
+		};
+		let _g1 = 0;
+		while (_g1 < toRemove.length) this.removeEntry(toRemove[_g1++]);
+		return toRemove;
+	}
+	
+	/**
+	Override in subclass: create stones and routes for a new data entry.
+	*/
+	createEntry(key, data) {
+		throw new Error("StoneFactory.createEntry must be overridden");
+	}
+	
+	/**
+	* Override in subclass: update an existing entry's stone configs in-place.
+	* Default implementation destroys and recreates the entry.
+	*/
+	updateEntry(key, data, existing) {
+		this.removeEntry(key);
+		this.entryMap.set(key, this.createEntry(key, data));
+	}
+	
+	/**
+	Override in subclass: add routes that are present on every sync (e.g., a database JSON file).
+	*/
+	addBaseRoutes() {
+	}
+	
+	/**
+	Remove an entry, deregistering its stones from the project.
+	*/
+	removeEntry(key) {
+		let entry = this.entryMap.get(key);
+		if (entry == null) {
+			return;
+		};
+		if (entry.stones != null) {
+			let stones = entry.stones;
+			let _g = 0;
+			while (_g < stones.length) {
+				let s = stones[_g];
+				++_g;
+				s.project.removeStone(s);
+			};
+		};
+		this.entryMap["delete"](key);
+	}
+	static get __name__() {
+		return "whet.stones.StoneFactory"
+	}
+	static get __super__() {
+		return Router
+	}
+	get __class__() {
+		return StoneFactory
+	}
+}
+StoneFactory.prototype.entryMap = null;
+

package/bin/whet.d.ts

@@ -3,6 +3,7 @@ export {addOption} from "./whet/Project"
 export {ZipStone} from "./whet/stones/Zip"
 export {ZipConfig} from "./whet/stones/Zip"
 export {Utils} from "./whet/Utils"
+export {StoneFactory} from "./whet/stones/StoneFactory"
 export {Stone} from "./whet/Stone"
 export {Router} from "./whet/route/Router"
 export {RemoteFileConfig} from "./whet/stones/RemoteFile"
@@ -17,6 +18,7 @@ export {Hxml} from "./whet/stones/haxe/Hxml"
 export {HaxeBuild} from "./whet/stones/haxe/HaxeBuild"
 export {FilesConfig} from "./whet/stones/Files"
 export {Files} from "./whet/stones/Files"
+export {FactoryEntry} from "./whet/stones/StoneFactory"
 export {DCE} from "./whet/stones/haxe/Hxml"
 export {ConfigStore} from "./whet/ConfigStore"
 export {BuildPlatform} from "./whet/stones/haxe/Hxml"

package/bin/whet.js

@@ -8,6 +8,7 @@ Whet_Fields_.main()
 export {addOption} from "./whet/Project.js"
 export {ZipStone} from "./whet/stones/Zip.js"
 export {Utils} from "./whet/Utils.js"
+export {StoneFactory} from "./whet/stones/StoneFactory.js"
 export {Stone} from "./whet/Stone.js"
 export {Router} from "./whet/route/Router.js"
 export {RemoteFile} from "./whet/stones/RemoteFile.js"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "whet",
-    "version": "0.1.1",
+    "version": "0.4.0",
     "description": "NodeJS based assets management and project tooling library.",
     "scripts": {
         "devinit": "npx dts2hx commander pino-pretty minimatch --modular --noLibWrap",
@@ -27,7 +27,7 @@
     "homepage": "https://github.com/Antriel/whet#readme",
     "dependencies": {
         "commander": "^14.0.3",
-        "minimatch": "^10.2.2",
+        "minimatch": "^10.2.5",
         "pino-pretty": "^13.1.3"
     },
     "devDependencies": {

package/bin/haxe/Log.d.ts

@@ -1,33 +0,0 @@
-import {PosInfos} from "./PosInfos"
-
-/**
-Log primarily provides the `trace()` method, which is invoked upon a call to
-`trace()` in Haxe code.
-*/
-export declare class Log {
-	
-	/**
-	Format the output of `trace` before printing it.
-	*/
-	static formatOutput(v: any, infos: PosInfos): string
-	
-	/**
-	Outputs `v` in a platform-dependent way.
-	
-	The second parameter `infos` is injected by the compiler and contains
-	information about the position where the `trace()` call was made.
-	
-	This method can be rebound to a custom function:
-	
-	var oldTrace = haxe.Log.trace; // store old function
-	haxe.Log.trace = function(v, ?infos) {
-	// handle trace
-	}
-	...
-	haxe.Log.trace = oldTrace;
-	
-	If it is bound to null, subsequent calls to `trace()` will cause an
-	exception.
-	*/
-	static trace(v: any, infos?: null | PosInfos): void
-}

package/bin/haxe/Log.js

@@ -1,61 +0,0 @@
-import {Register} from "../genes/Register.js"
-import {Std} from "../Std.js"
-
-const $global = Register.$global
-
-/**
-Log primarily provides the `trace()` method, which is invoked upon a call to
-`trace()` in Haxe code.
-*/
-export const Log = Register.global("$hxClasses")["haxe.Log"] = 
-class Log {
-	
-	/**
-	Format the output of `trace` before printing it.
-	*/
-	static formatOutput(v, infos) {
-		let str = Std.string(v);
-		if (infos == null) {
-			return str;
-		};
-		let pstr = infos.fileName + ":" + infos.lineNumber;
-		if (infos.customParams != null) {
-			let _g = 0;
-			let _g1 = infos.customParams;
-			while (_g < _g1.length) str += ", " + Std.string(_g1[_g++]);
-		};
-		return pstr + ": " + str;
-	}
-	
-	/**
-	Outputs `v` in a platform-dependent way.
-	
-	The second parameter `infos` is injected by the compiler and contains
-	information about the position where the `trace()` call was made.
-	
-	This method can be rebound to a custom function:
-	
-	var oldTrace = haxe.Log.trace; // store old function
-	haxe.Log.trace = function(v, ?infos) {
-	// handle trace
-	}
-	...
-	haxe.Log.trace = oldTrace;
-	
-	If it is bound to null, subsequent calls to `trace()` will cause an
-	exception.
-	*/
-	static trace(v, infos) {
-		let str = Log.formatOutput(v, infos);
-		if (typeof(console) != "undefined" && console.log != null) {
-			console.log(str);
-		};
-	}
-	static get __name__() {
-		return "haxe.Log"
-	}
-	get __class__() {
-		return Log
-	}
-}
-

package/bin/pino_pretty/PrettyOptions.d.ts

@@ -1,98 +0,0 @@
-import {Prettifier} from "./default_/Prettifier"
-
-export type PrettyOptions = {
-	/**
-	Opens the file with the 'a' flag.
-	*/
-	append?: null | boolean, 
-	/**
-	If set to true, will add color information to the formatted output message.
-	*/
-	colorize?: null | boolean, 
-	/**
-	Appends carriage return and line feed, instead of just a line feed, to the formatted log line.
-	*/
-	crlf?: null | boolean, 
-	/**
-	Provides the ability to add a custom prettify function for specific log properties.
-	`customPrettifiers` is an object, where keys are log properties that will be prettified
-	and value is the prettify function itself.
-	For example, if a log line contains a query property, you can specify a prettifier for it:
-	*/
-	customPrettifiers?: null | {[key: string]: Prettifier}, 
-	/**
-	The file, file descriptor, or stream to write to.  Defaults to 1 (stdout).
-	*/
-	destination?: null | any, 
-	/**
-	Define the log keys that are associated with error like objects.
-	*/
-	errorLikeObjectKeys?: null | string[], 
-	/**
-	When formatting an error object, display this list of properties.
-	The list should be a comma separated list of properties.
-	*/
-	errorProps?: null | string, 
-	/**
-	Hide objects from output (but not error object).
-	*/
-	hideObject?: null | boolean, 
-	/**
-	Ignore one or several keys.
-	Will be overridden by the option include if include is presented.
-	*/
-	ignore?: null | string, 
-	/**
-	Include one or several keys.
-	*/
-	include?: null | string, 
-	/**
-	If set to true, it will print the name of the log level as the first field in the log line.
-	*/
-	levelFirst?: null | boolean, 
-	/**
-	Define the key that contains the level of the log.
-	*/
-	levelKey?: null | string, 
-	/**
-	Output the log level using the specified label.
-	*/
-	levelLabel?: null | string, 
-	/**
-	Format output of message, e.g. {level} - {pid} will output message: INFO - 1123
-	*/
-	messageFormat?: null | any, 
-	/**
-	The key in the JSON object to use as the highlighted message.
-	*/
-	messageKey?: null | string, 
-	/**
-	The minimum log level to include in the output.
-	*/
-	minimumLevel?: null | any, 
-	/**
-	Ensure directory for destination file exists.
-	*/
-	mkdir?: null | boolean, 
-	/**
-	Print each log message on a single line (errors will still be multi-line).
-	*/
-	singleLine?: null | boolean, 
-	/**
-	Makes messaging synchronous.
-	*/
-	sync?: null | boolean, 
-	/**
-	The key in the JSON object to use for timestamp display.
-	*/
-	timestampKey?: null | string, 
-	/**
-	Translate the epoch time value into a human readable date and time string. This flag also can set the format
-	string to apply when translating the date to human readable format. For a list of available pattern letters
-	see the {@link https://www.npmjs.com/package/dateformat|dateformat documentation}.
-	- The default format is `yyyy-mm-dd HH:MM:ss.l o` in UTC.
-	- Requires a `SYS:` prefix to translate time to the local system's timezone. Use the shortcut `SYS:standard`
-	to translate time to `yyyy-mm-dd HH:MM:ss.l o` in system timezone.
-	*/
-	translateTime?: null | any
-}

package/bin/pino_pretty/default_/MessageFormatFunc.d.ts

@@ -1,2 +0,0 @@
-
-export type MessageFormatFunc = ((log: {[key: string]: any}, messageKey: string, levelLabel: string) => string)

package/bin/pino_pretty/default_/Prettifier.d.ts

@@ -1,2 +0,0 @@
-
-export type Prettifier = ((inputData: any) => string)

package/bin/whet/extern/Minimatch.d.ts

@@ -1,77 +0,0 @@
-
-export type IOptions = {
-	/**
-	Dump a ton of stuff to stderr.
-	*/
-	debug?: null | boolean, 
-	/**
-	Allow patterns to match filenames starting with a period,
-	even if the pattern does not explicitly have a period in that spot.
-	
-	Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
-	*/
-	dot?: null | boolean, 
-	/**
-	Returns from negate expressions the same as if they were not negated.
-	(Ie, true on a hit, false on a miss.)
-	*/
-	flipNegate?: null | boolean, 
-	/**
-	If set, then patterns without slashes will be matched
-	against the basename of the path if it contains slashes. For example,
-	`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
-	*/
-	matchBase?: null | boolean, 
-	/**
-	Do not expand `{a,b}` and `{1..3}` brace sets.
-	*/
-	nobrace?: null | boolean, 
-	/**
-	Perform a case-insensitive match.
-	*/
-	nocase?: null | boolean, 
-	/**
-	Suppress the behavior of treating `#` at the start of a pattern as a comment.
-	*/
-	nocomment?: null | boolean, 
-	/**
-	Disable "extglob" style patterns like `+(a|b)`.
-	*/
-	noext?: null | boolean, 
-	/**
-	Disable `**` matching against multiple folder names.
-	*/
-	noglobstar?: null | boolean, 
-	/**
-	Suppress the behavior of treating a leading `!` character as negation.
-	*/
-	nonegate?: null | boolean, 
-	/**
-	When a match is not found by `minimatch.match`,
-	return a list containing the pattern itself if this option is set.
-	Otherwise, an empty list is returned if there are no matches.
-	*/
-	nonull?: null | boolean, 
-	/**
-	Compare a partial path to a pattern.  As long as the parts of the path that
-	are present are not contradicted by the pattern, it will be treated as a
-	match. This is useful in applications where you're walking through a
-	folder structure, and don't yet have the full path, but want to ensure that
-	you do not walk down paths that can never be a match.
-	*/
-	partial?: null | boolean, 
-	/**
-	Use `\\` as a path separator _only_, and _never_ as an escape
-	character. If set, all `\\` characters are replaced with `/` in
-	the pattern. Note that this makes it **impossible** to match
-	against paths containing literal glob pattern characters, but
-	allows matching with patterns constructed using `path.join()` and
-	`path.resolve()` on Windows platforms, mimicking the (buggy!)
-	behavior of earlier versions on Windows. Please use with
-	caution, and be mindful of the caveat about Windows paths
-	
-	For legacy reasons, this is also set if
-	`options.allowWindowsEscape` is set to the exact value `false`.
-	*/
-	windowsPathsNoEscape?: null | boolean
-}