tungsten 0.4.11 → 0.4.13

package/vendor/sxy-lib-objects.js

@@ -0,0 +1,156 @@
+import { createRequire as __tungstenCreateRequire } from 'node:module';
+const require = __tungstenCreateRequire(import.meta.url);
+var objects = {};
+
+var hasRequiredObjects;
+
+function requireObjects () {
+	if (hasRequiredObjects) return objects;
+	hasRequiredObjects = 1;
+	Object.defineProperty(objects, "__esModule", { value: true });
+	objects.assign = objects.set = objects.omit = objects.limit = objects.pick = objects.empty = objects.clear = objects.freezeDeep = objects.deepFreeze = objects.forEach = objects.mapToArray = objects.remap = objects.map = objects.reduce = objects.block = objects.guard = objects.filter = objects.count = void 0;
+	function count(object) {
+	    return Object.keys(object).length;
+	}
+	objects.count = count;
+	function filter(object, func) {
+	    const newObj = {};
+	    for (const key in object) {
+	        if (func(key, object[key], object)) {
+	            newObj[key] = object[key];
+	        }
+	    }
+	    return newObj;
+	}
+	objects.filter = filter;
+	function guard(object, func) {
+	    const newObj = {};
+	    for (const key in object) {
+	        const value = object[key];
+	        if (func(value, key, object)) {
+	            newObj[key] = value;
+	        }
+	    }
+	    return newObj;
+	}
+	objects.guard = guard;
+	function block(object, func) {
+	    const newObj = {};
+	    for (const key in object) {
+	        const value = object[key];
+	        if (!func(value, key, object)) {
+	            // @ts-expect-error -- TS doesn't seem to be excluding G, though we know that it is correct
+	            newObj[key] = value;
+	        }
+	    }
+	    return newObj;
+	}
+	objects.block = block;
+	function reduce(object, func, initial) {
+	    for (const key in object) {
+	        initial = func(initial, key, object[key], object);
+	    }
+	    return initial;
+	}
+	objects.reduce = reduce;
+	//export type MapFunction<O extends object, T> = (key: keyof O & string, value: ValueOf<O>, object: O) => T
+	function map(object, func) {
+	    const newObj = {};
+	    for (const key in object) {
+	        newObj[key] = func(key, object[key], object);
+	    }
+	    return newObj;
+	}
+	objects.map = map;
+	function remap(object, func) {
+	    const newObj = {};
+	    for (const key in object) {
+	        const [newKey, newValue] = func(key, object[key], object);
+	        newObj[newKey] = newValue;
+	    }
+	    // eslint-disable-next-line no-type-assertion/no-type-assertion
+	    return newObj;
+	}
+	objects.remap = remap;
+	function mapToArray(object, func) {
+	    const result = [];
+	    for (const key in object) {
+	        result.push(func(key, object[key], object));
+	    }
+	    return result;
+	}
+	objects.mapToArray = mapToArray;
+	function forEach(object, func) {
+	    for (const key in object) {
+	        func(key, object[key], object);
+	    }
+	}
+	objects.forEach = forEach;
+	function deepFreeze(object) {
+	    if (object && typeof object === "object" && !Object.isFrozen(object)) {
+	        Object.freeze(object);
+	        Object.getOwnPropertyNames(object).forEach(prop => deepFreeze(object[prop]));
+	    }
+	    return object;
+	}
+	objects.deepFreeze = deepFreeze;
+	objects.freezeDeep = deepFreeze;
+	function clear(object) {
+	    const properties = Object.getOwnPropertyNames(object);
+	    for (const property of properties) {
+	        delete object[property];
+	    }
+	}
+	objects.clear = clear;
+	objects.empty = clear;
+	// how?
+	function pick(object, ...pickKeys) {
+	    return Object.keys(object)
+	        .filter(key => pickKeys.includes(key))
+	        .reduce((newObject, key) => {
+	        newObject[key] = object[key];
+	        return newObject;
+	    }, {});
+	}
+	objects.pick = pick;
+	objects.limit = pick;
+	function omit(object, ...omitKeys) {
+	    return filter(object, (key) => !omitKeys.includes(key));
+	}
+	objects.omit = omit;
+	function set(object, key, value) {
+	    object[key] = value;
+	    return object;
+	}
+	objects.set = set;
+	function assign(o, p) {
+	    const result = structuredClone(o);
+	    for (const key in p) {
+	        result[key] = p[key];
+	    }
+	    return result;
+	}
+	objects.assign = assign;
+	// import { UnionToIntersection } from 'sxy-types'
+	// export function safelyCombine<Objects extends ArrayMinLength<object, 1>>(...objects: Objects) {
+	//     type Result = UnionToIntersection<Objects[number]>
+	//     const newObj = { ...objects[0] } as Result
+	//     for (let i = 1; i < objects.length; i++) {
+	//         const o = objects[i] as object
+	//         for (const key in o) {
+	//             if (key in newObj) {
+	//                 throw new Error(`safelyCombine() Error, key ${key} is duplicated`)
+	//             }
+	//             newObj[key as never] = o[key as never]
+	//         }
+	//     }
+	//     return newObj
+	// }
+	return objects;
+}
+
+var objectsExports = requireObjects();
+
+const __v0 = objectsExports["__esModule"];const __v1 = objectsExports["assign"];const __v2 = objectsExports["block"];const __v3 = objectsExports["clear"];const __v4 = objectsExports["count"];const __v5 = objectsExports["deepFreeze"];const __v6 = objectsExports["empty"];const __v7 = objectsExports["filter"];const __v8 = objectsExports["forEach"];const __v9 = objectsExports["freezeDeep"];const __v10 = objectsExports["guard"];const __v11 = objectsExports["limit"];const __v12 = objectsExports["map"];const __v13 = objectsExports["mapToArray"];const __v14 = objectsExports["omit"];const __v15 = objectsExports["pick"];const __v16 = objectsExports["reduce"];const __v17 = objectsExports["remap"];const __v18 = objectsExports["set"];
+
+export { __v0 as __esModule, __v1 as assign, __v2 as block, __v3 as clear, __v4 as count, __v5 as deepFreeze, objectsExports as default, __v6 as empty, __v7 as filter, __v8 as forEach, __v9 as freezeDeep, __v10 as guard, __v11 as limit, __v12 as map, __v13 as mapToArray, __v14 as omit, __v15 as pick, __v16 as reduce, __v17 as remap, __v18 as set };

package/vendor/sxy-lib-promises.js

@@ -0,0 +1,47 @@
+import { createRequire as __tungstenCreateRequire } from 'node:module';
+const require = __tungstenCreateRequire(import.meta.url);
+var promises = {};
+
+var hasRequiredPromises;
+
+function requirePromises () {
+	if (hasRequiredPromises) return promises;
+	hasRequiredPromises = 1;
+	var __awaiter = (promises && promises.__awaiter) || function (thisArg, _arguments, P, generator) {
+	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+	    return new (P || (P = Promise))(function (resolve, reject) {
+	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+	        step((generator = generator.apply(thisArg, _arguments || [])).next());
+	    });
+	};
+	Object.defineProperty(promises, "__esModule", { value: true });
+	promises.allObj = void 0;
+	function allObj(promisesMap) {
+	    return __awaiter(this, void 0, void 0, function* () {
+	        const results = {};
+	        const promisesArr = [];
+	        for (const key in promisesMap) {
+	            const promise = promisesMap[key];
+	            if (promise instanceof Promise) {
+	                promisesArr.push(promise.then(result => results[key] = result));
+	            }
+	            else {
+	                results[key] = promise;
+	            }
+	        }
+	        yield Promise.all(promisesArr);
+	        return results;
+	    });
+	}
+	promises.allObj = allObj;
+	//Promise.allMap = allObj
+	return promises;
+}
+
+var promisesExports = requirePromises();
+
+const __v0 = promisesExports["__esModule"];const __v1 = promisesExports["allObj"];
+
+export { __v0 as __esModule, __v1 as allObj, promisesExports as default };

package/vendor/sxy-package-investigator.js

@@ -0,0 +1,202 @@
+import { createRequire as __tungstenCreateRequire } from 'node:module';
+const require = __tungstenCreateRequire(import.meta.url);
+import require$$2 from 'url';
+import require$$0 from 'path';
+import require$$0$1 from 'fs';
+
+var dist = {};
+
+var getPackageJson = {};
+
+var findPackageJson;
+var hasRequiredFindPackageJson;
+
+function requireFindPackageJson () {
+	if (hasRequiredFindPackageJson) return findPackageJson;
+	hasRequiredFindPackageJson = 1;
+
+	var path = require$$0
+	  , fs = require$$0$1;
+
+	/**
+	 * Attempt to somewhat safely parse the JSON.
+	 *
+	 * @param {String} data JSON blob that needs to be parsed.
+	 * @returns {Object|false} Parsed JSON or false.
+	 * @api private
+	 */
+	function parse(data) {
+	  data = data.toString('utf-8');
+
+	  //
+	  // Remove a possible UTF-8 BOM (byte order marker) as this can lead to parse
+	  // values when passed in to the JSON.parse.
+	  //
+	  if (data.charCodeAt(0) === 0xFEFF) data = data.slice(1);
+
+	  try { return JSON.parse(data); }
+	  catch (e) { return false; }
+	}
+
+	var iteratorSymbol = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.iterator : null;
+	/**
+	 * Add `Symbol.iterator` method if Symbols are available
+	 *
+	 * @param {Object} Iterator interface.
+	 * @returns {Object} Iterator interface.
+	 * @api private
+	 */
+	function addSymbolIterator(result) {
+	  if (!iteratorSymbol) {
+	    return result;
+	  }
+	  result[iteratorSymbol] = function () { return this; };
+	  return result;
+	}
+
+	/**
+	 * Find package.json files.
+	 *
+	 * @param {String|Object} root The root directory we should start searching in.
+	 * @returns {Object} Iterator interface.
+	 * @api public
+	 */
+	findPackageJson = function find(root) {
+	  root = root || process.cwd();
+	  if (typeof root !== "string") {
+	    if (typeof root === "object" && typeof root.filename === 'string') {
+	      root = root.filename;
+	    } else {
+	      throw new Error("Must pass a filename string or a module object to finder");
+	    }
+	  }
+	  return addSymbolIterator({
+	    /**
+	     * Return the parsed package.json that we find in a parent folder.
+	     *
+	     * @returns {Object} Value, filename and indication if the iteration is done.
+	     * @api public
+	     */
+	    next: function next() {
+	      if (root.match(/^(\w:\\|\/)$/)) return addSymbolIterator({
+	        value: undefined,
+	        filename: undefined,
+	        done: true
+	      });
+
+	      var file = path.join(root, 'package.json')
+	        , data;
+
+	      root = path.resolve(root, '..');
+
+	      if (fs.existsSync(file) && (data = parse(fs.readFileSync(file)))) {
+	        data.__path = file;
+
+	        return addSymbolIterator({
+	          value: data,
+	          filename: file,
+	          done: false
+	        });
+	      }
+
+	      return next();
+	    }
+	  });
+	};
+	return findPackageJson;
+}
+
+var hasRequiredGetPackageJson;
+
+function requireGetPackageJson () {
+	if (hasRequiredGetPackageJson) return getPackageJson;
+	hasRequiredGetPackageJson = 1;
+	var __importDefault = (getPackageJson && getPackageJson.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(getPackageJson, "__esModule", { value: true });
+	getPackageJson.getPackageJson = void 0;
+	const url_1 = require$$2;
+	const find_package_json_1 = __importDefault(requireFindPackageJson());
+	function getPackageJson$1(location) {
+	    if (location.startsWith('file:'))
+	        location = (0, url_1.fileURLToPath)(location);
+	    const packageJson = (0, find_package_json_1.default)(location).next();
+	    // error handling
+	    return packageJson;
+	}
+	getPackageJson.getPackageJson = getPackageJson$1;
+	return getPackageJson;
+}
+
+var findPackageDirectory = {};
+
+var hasRequiredFindPackageDirectory;
+
+function requireFindPackageDirectory () {
+	if (hasRequiredFindPackageDirectory) return findPackageDirectory;
+	hasRequiredFindPackageDirectory = 1;
+	Object.defineProperty(findPackageDirectory, "__esModule", { value: true });
+	findPackageDirectory.findPackageDirectory = void 0;
+	const fs_1 = require$$0$1;
+	const path_1 = require$$0;
+	const url_1 = require$$2;
+	function searchLocation(location) {
+	    return (0, path_1.join)(location, 'package.json');
+	}
+	function findPackageDirectory$1(location) {
+	    if (location.startsWith('file:'))
+	        location = (0, url_1.fileURLToPath)(location);
+	    try {
+	        //location = (lstatSync('file://' + location).isDirectory())
+	        location = ((0, fs_1.lstatSync)(location).isDirectory())
+	            ? location
+	            : (0, path_1.dirname)(location);
+	    }
+	    catch (e) {
+	        // if it doesn't exists, just take the dirname and search
+	        location = (0, path_1.dirname)(location);
+	    }
+	    while (!(0, fs_1.existsSync)(searchLocation(location))) {
+	        const newLocation = (0, path_1.dirname)(location);
+	        if (newLocation === location)
+	            break; // we are at the root
+	        else
+	            location = newLocation;
+	    }
+	    return location;
+	}
+	findPackageDirectory.findPackageDirectory = findPackageDirectory$1;
+	// const { dirname } = require('path')
+	// const { fileURLToPath } = require('url')
+	// const packageJsonFinder = require('find-package-json')
+	// module.exports.findPackageDirectory = function findPackageDirectory(location) {
+	//     if (location.startsWith('file:')) location = fileURLToPath(location)
+	//     const packageJson = packageJsonFinder(location).next()
+	//     //console.log('packageJson', packageJson)
+	//     return dirname(packageJson.filename)
+	// }
+	return findPackageDirectory;
+}
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.findPackageDirectory = exports.getPackageJson = void 0;
+		var getPackageJson_js_1 = requireGetPackageJson();
+		Object.defineProperty(exports, "getPackageJson", { enumerable: true, get: function () { return getPackageJson_js_1.getPackageJson; } });
+		var findPackageDirectory_js_1 = requireFindPackageDirectory();
+		Object.defineProperty(exports, "findPackageDirectory", { enumerable: true, get: function () { return findPackageDirectory_js_1.findPackageDirectory; } }); 
+	} (dist));
+	return dist;
+}
+
+var distExports = requireDist();
+
+const __v0 = distExports["__esModule"];const __v1 = distExports["findPackageDirectory"];const __v2 = distExports["getPackageJson"];
+
+export { __v0 as __esModule, distExports as default, __v1 as findPackageDirectory, __v2 as getPackageJson };