@highstate/designer 0.1.0 → 0.2.1

package/.output/server/node_modules/better-lock/dist/tools.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assign = exports.callbackWithPromise = exports.makeLog = exports.noop = exports.isNumber = exports.isObject = exports.isFunction = exports.isString = void 0;
+function isString(val) {
+    return typeof val === 'string';
+}
+exports.isString = isString;
+function isFunction(val) {
+    return typeof val === 'function';
+}
+exports.isFunction = isFunction;
+function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+exports.isObject = isObject;
+function isNumber(val, includeInfinity, includeNaN) {
+    if (includeInfinity === void 0) { includeInfinity = false; }
+    if (includeNaN === void 0) { includeNaN = false; }
+    if (typeof val !== 'number') {
+        return false;
+    }
+    if (!includeInfinity && (val === Number.POSITIVE_INFINITY || val === Number.NEGATIVE_INFINITY)) {
+        return false;
+    }
+    if (!includeNaN && isNaN(val)) {
+        return false;
+    }
+    return true;
+}
+exports.isNumber = isNumber;
+function noop() {
+    // Nothing
+}
+exports.noop = noop;
+function makeLog(name, doLog) {
+    if (!doLog) {
+        return noop;
+    }
+    if (doLog === true) {
+        doLog = console.log.bind(console);
+    }
+    if (name) {
+        name = '[' + name + '] ';
+    }
+    return function log(msg) {
+        if (name) {
+            doLog(name + msg);
+        }
+        else {
+            doLog(msg);
+        }
+    };
+}
+exports.makeLog = makeLog;
+/**
+ * Create a wrapped promise + callback construct
+ */
+function callbackWithPromise() {
+    var callback;
+    var promise = new Promise(function (resolve, reject) {
+        callback = function (err, result) {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(result);
+            }
+        };
+    });
+    callback.promise = promise;
+    return callback;
+}
+exports.callbackWithPromise = callbackWithPromise;
+/**
+ * Assign properties from sources to target, skipping over undefined-s
+ * @param target Target object which will be mutated
+ * @param sources One or more source objects which will provide properties
+ */
+function assign(target, sources) {
+    for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+        var source = sources_1[_i];
+        if (!isObject(source)) {
+            // We must have an object to assign
+            continue;
+        }
+        for (var key in source) {
+            if (!source.hasOwnProperty(key)) {
+                continue;
+            }
+            var sourceValue = source[key];
+            if (sourceValue === undefined) {
+                // Do not overwrite undefineds
+                continue;
+            }
+            var targetValue = target[key];
+            if (isObject(sourceValue) && isObject(targetValue)) {
+                // Merge deep.
+                var cloneRoot = targetValue.constructor ? new targetValue.constructor() : {};
+                target[key] = assign(cloneRoot, [targetValue, sourceValue]);
+                continue;
+            }
+            // In all other cases, copy by reference
+            target[key] = sourceValue;
+        }
+    }
+    return target;
+}
+exports.assign = assign;
+//# sourceMappingURL=tools.js.map

package/.output/server/node_modules/better-lock/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "better-lock",
+  "version": "3.2.0",
+  "description": "A (better) node.js lock library",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "test": "jest",
+    "watch": "jest --watchAll",
+    "lint": "eslint ./src",
+    "coverage": "jest --coverage",
+    "docs": "typedoc src/index.ts --excludePrivate --excludeProtected --excludeExternals"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/panta82/better-lock.git"
+  },
+  "keywords": [
+    "lock",
+    "mutex",
+    "async",
+    "wait",
+    "enter",
+    "block",
+    "sync"
+  ],
+  "devDependencies": {
+    "@types/jest": "29",
+    "@typescript-eslint/eslint-plugin": "^4.25.0",
+    "@typescript-eslint/parser": "^4.25.0",
+    "eslint": "^7.27.0",
+    "eslint-config-prettier": "^8.3.0",
+    "import-sort-style-module": "^6.0.0",
+    "jest": "29",
+    "prettier": "latest",
+    "prettier-plugin-import-sort": "0.0.7",
+    "ts-jest": "29",
+    "typedoc": "0.23.0",
+    "typedoc-plugin-missing-exports": "0.23.0",
+    "typescript": "^4.3.2"
+  },
+  "author": "Ivan Pantic",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/panta82/better-lock/issues"
+  },
+  "homepage": "https://github.com/panta82/better-lock#readme",
+  "importSort": {
+    ".ts, .tsx": {
+      "style": "module",
+      "parser": "typescript"
+    },
+    ".js, .jsx": {
+      "style": "module"
+    }
+  },
+  "dependencies": {}
+}

package/.output/server/node_modules/cacheable-lookup/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "cacheable-lookup",
+  "version": "5.0.4",
+  "description": "A cacheable dns.lookup(…) that respects the TTL",
+  "engines": {
+    "node": ">=10.6.0"
+  },
+  "files": [
+    "source",
+    "index.d.ts"
+  ],
+  "main": "source/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "xo && nyc --reporter=lcovonly --reporter=text ava && tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/szmarczak/cacheable-lookup.git"
+  },
+  "keywords": [
+    "dns",
+    "lookup",
+    "cacheable",
+    "ttl"
+  ],
+  "author": "Szymon Marczak",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/szmarczak/cacheable-lookup/issues"
+  },
+  "homepage": "https://github.com/szmarczak/cacheable-lookup#readme",
+  "devDependencies": {
+    "@types/keyv": "^3.1.1",
+    "ava": "^3.8.2",
+    "benchmark": "^2.1.4",
+    "coveralls": "^3.0.9",
+    "keyv": "^4.0.0",
+    "nyc": "^15.0.0",
+    "proxyquire": "^2.1.3",
+    "tsd": "^0.11.0",
+    "quick-lru": "^5.1.0",
+    "xo": "^0.25.3"
+  }
+}

package/.output/server/node_modules/cacheable-lookup/source/index.js

@@ -0,0 +1,436 @@
+'use strict';
+const {
+	V4MAPPED,
+	ADDRCONFIG,
+	ALL,
+	promises: {
+		Resolver: AsyncResolver
+	},
+	lookup: dnsLookup
+} = require('dns');
+const {promisify} = require('util');
+const os = require('os');
+
+const kCacheableLookupCreateConnection = Symbol('cacheableLookupCreateConnection');
+const kCacheableLookupInstance = Symbol('cacheableLookupInstance');
+const kExpires = Symbol('expires');
+
+const supportsALL = typeof ALL === 'number';
+
+const verifyAgent = agent => {
+	if (!(agent && typeof agent.createConnection === 'function')) {
+		throw new Error('Expected an Agent instance as the first argument');
+	}
+};
+
+const map4to6 = entries => {
+	for (const entry of entries) {
+		if (entry.family === 6) {
+			continue;
+		}
+
+		entry.address = `::ffff:${entry.address}`;
+		entry.family = 6;
+	}
+};
+
+const getIfaceInfo = () => {
+	let has4 = false;
+	let has6 = false;
+
+	for (const device of Object.values(os.networkInterfaces())) {
+		for (const iface of device) {
+			if (iface.internal) {
+				continue;
+			}
+
+			if (iface.family === 'IPv6') {
+				has6 = true;
+			} else {
+				has4 = true;
+			}
+
+			if (has4 && has6) {
+				return {has4, has6};
+			}
+		}
+	}
+
+	return {has4, has6};
+};
+
+const isIterable = map => {
+	return Symbol.iterator in map;
+};
+
+const ttl = {ttl: true};
+const all = {all: true};
+
+class CacheableLookup {
+	constructor({
+		cache = new Map(),
+		maxTtl = Infinity,
+		fallbackDuration = 3600,
+		errorTtl = 0.15,
+		resolver = new AsyncResolver(),
+		lookup = dnsLookup
+	} = {}) {
+		this.maxTtl = maxTtl;
+		this.errorTtl = errorTtl;
+
+		this._cache = cache;
+		this._resolver = resolver;
+		this._dnsLookup = promisify(lookup);
+
+		if (this._resolver instanceof AsyncResolver) {
+			this._resolve4 = this._resolver.resolve4.bind(this._resolver);
+			this._resolve6 = this._resolver.resolve6.bind(this._resolver);
+		} else {
+			this._resolve4 = promisify(this._resolver.resolve4.bind(this._resolver));
+			this._resolve6 = promisify(this._resolver.resolve6.bind(this._resolver));
+		}
+
+		this._iface = getIfaceInfo();
+
+		this._pending = {};
+		this._nextRemovalTime = false;
+		this._hostnamesToFallback = new Set();
+
+		if (fallbackDuration < 1) {
+			this._fallback = false;
+		} else {
+			this._fallback = true;
+
+			const interval = setInterval(() => {
+				this._hostnamesToFallback.clear();
+			}, fallbackDuration * 1000);
+
+			/* istanbul ignore next: There is no `interval.unref()` when running inside an Electron renderer */
+			if (interval.unref) {
+				interval.unref();
+			}
+		}
+
+		this.lookup = this.lookup.bind(this);
+		this.lookupAsync = this.lookupAsync.bind(this);
+	}
+
+	set servers(servers) {
+		this.clear();
+
+		this._resolver.setServers(servers);
+	}
+
+	get servers() {
+		return this._resolver.getServers();
+	}
+
+	lookup(hostname, options, callback) {
+		if (typeof options === 'function') {
+			callback = options;
+			options = {};
+		} else if (typeof options === 'number') {
+			options = {
+				family: options
+			};
+		}
+
+		if (!callback) {
+			throw new Error('Callback must be a function.');
+		}
+
+		// eslint-disable-next-line promise/prefer-await-to-then
+		this.lookupAsync(hostname, options).then(result => {
+			if (options.all) {
+				callback(null, result);
+			} else {
+				callback(null, result.address, result.family, result.expires, result.ttl);
+			}
+		}, callback);
+	}
+
+	async lookupAsync(hostname, options = {}) {
+		if (typeof options === 'number') {
+			options = {
+				family: options
+			};
+		}
+
+		let cached = await this.query(hostname);
+
+		if (options.family === 6) {
+			const filtered = cached.filter(entry => entry.family === 6);
+
+			if (options.hints & V4MAPPED) {
+				if ((supportsALL && options.hints & ALL) || filtered.length === 0) {
+					map4to6(cached);
+				} else {
+					cached = filtered;
+				}
+			} else {
+				cached = filtered;
+			}
+		} else if (options.family === 4) {
+			cached = cached.filter(entry => entry.family === 4);
+		}
+
+		if (options.hints & ADDRCONFIG) {
+			const {_iface} = this;
+			cached = cached.filter(entry => entry.family === 6 ? _iface.has6 : _iface.has4);
+		}
+
+		if (cached.length === 0) {
+			const error = new Error(`cacheableLookup ENOTFOUND ${hostname}`);
+			error.code = 'ENOTFOUND';
+			error.hostname = hostname;
+
+			throw error;
+		}
+
+		if (options.all) {
+			return cached;
+		}
+
+		return cached[0];
+	}
+
+	async query(hostname) {
+		let cached = await this._cache.get(hostname);
+
+		if (!cached) {
+			const pending = this._pending[hostname];
+
+			if (pending) {
+				cached = await pending;
+			} else {
+				const newPromise = this.queryAndCache(hostname);
+				this._pending[hostname] = newPromise;
+
+				try {
+					cached = await newPromise;
+				} finally {
+					delete this._pending[hostname];
+				}
+			}
+		}
+
+		cached = cached.map(entry => {
+			return {...entry};
+		});
+
+		return cached;
+	}
+
+	async _resolve(hostname) {
+		const wrap = async promise => {
+			try {
+				return await promise;
+			} catch (error) {
+				if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
+					return [];
+				}
+
+				throw error;
+			}
+		};
+
+		// ANY is unsafe as it doesn't trigger new queries in the underlying server.
+		const [A, AAAA] = await Promise.all([
+			this._resolve4(hostname, ttl),
+			this._resolve6(hostname, ttl)
+		].map(promise => wrap(promise)));
+
+		let aTtl = 0;
+		let aaaaTtl = 0;
+		let cacheTtl = 0;
+
+		const now = Date.now();
+
+		for (const entry of A) {
+			entry.family = 4;
+			entry.expires = now + (entry.ttl * 1000);
+
+			aTtl = Math.max(aTtl, entry.ttl);
+		}
+
+		for (const entry of AAAA) {
+			entry.family = 6;
+			entry.expires = now + (entry.ttl * 1000);
+
+			aaaaTtl = Math.max(aaaaTtl, entry.ttl);
+		}
+
+		if (A.length > 0) {
+			if (AAAA.length > 0) {
+				cacheTtl = Math.min(aTtl, aaaaTtl);
+			} else {
+				cacheTtl = aTtl;
+			}
+		} else {
+			cacheTtl = aaaaTtl;
+		}
+
+		return {
+			entries: [
+				...A,
+				...AAAA
+			],
+			cacheTtl
+		};
+	}
+
+	async _lookup(hostname) {
+		try {
+			const entries = await this._dnsLookup(hostname, {
+				all: true
+			});
+
+			return {
+				entries,
+				cacheTtl: 0
+			};
+		} catch (_) {
+			return {
+				entries: [],
+				cacheTtl: 0
+			};
+		}
+	}
+
+	async _set(hostname, data, cacheTtl) {
+		if (this.maxTtl > 0 && cacheTtl > 0) {
+			cacheTtl = Math.min(cacheTtl, this.maxTtl) * 1000;
+			data[kExpires] = Date.now() + cacheTtl;
+
+			try {
+				await this._cache.set(hostname, data, cacheTtl);
+			} catch (error) {
+				this.lookupAsync = async () => {
+					const cacheError = new Error('Cache Error. Please recreate the CacheableLookup instance.');
+					cacheError.cause = error;
+
+					throw cacheError;
+				};
+			}
+
+			if (isIterable(this._cache)) {
+				this._tick(cacheTtl);
+			}
+		}
+	}
+
+	async queryAndCache(hostname) {
+		if (this._hostnamesToFallback.has(hostname)) {
+			return this._dnsLookup(hostname, all);
+		}
+
+		let query = await this._resolve(hostname);
+
+		if (query.entries.length === 0 && this._fallback) {
+			query = await this._lookup(hostname);
+
+			if (query.entries.length !== 0) {
+				// Use `dns.lookup(...)` for that particular hostname
+				this._hostnamesToFallback.add(hostname);
+			}
+		}
+
+		const cacheTtl = query.entries.length === 0 ? this.errorTtl : query.cacheTtl;
+		await this._set(hostname, query.entries, cacheTtl);
+
+		return query.entries;
+	}
+
+	_tick(ms) {
+		const nextRemovalTime = this._nextRemovalTime;
+
+		if (!nextRemovalTime || ms < nextRemovalTime) {
+			clearTimeout(this._removalTimeout);
+
+			this._nextRemovalTime = ms;
+
+			this._removalTimeout = setTimeout(() => {
+				this._nextRemovalTime = false;
+
+				let nextExpiry = Infinity;
+
+				const now = Date.now();
+
+				for (const [hostname, entries] of this._cache) {
+					const expires = entries[kExpires];
+
+					if (now >= expires) {
+						this._cache.delete(hostname);
+					} else if (expires < nextExpiry) {
+						nextExpiry = expires;
+					}
+				}
+
+				if (nextExpiry !== Infinity) {
+					this._tick(nextExpiry - now);
+				}
+			}, ms);
+
+			/* istanbul ignore next: There is no `timeout.unref()` when running inside an Electron renderer */
+			if (this._removalTimeout.unref) {
+				this._removalTimeout.unref();
+			}
+		}
+	}
+
+	install(agent) {
+		verifyAgent(agent);
+
+		if (kCacheableLookupCreateConnection in agent) {
+			throw new Error('CacheableLookup has been already installed');
+		}
+
+		agent[kCacheableLookupCreateConnection] = agent.createConnection;
+		agent[kCacheableLookupInstance] = this;
+
+		agent.createConnection = (options, callback) => {
+			if (!('lookup' in options)) {
+				options.lookup = this.lookup;
+			}
+
+			return agent[kCacheableLookupCreateConnection](options, callback);
+		};
+	}
+
+	uninstall(agent) {
+		verifyAgent(agent);
+
+		if (agent[kCacheableLookupCreateConnection]) {
+			if (agent[kCacheableLookupInstance] !== this) {
+				throw new Error('The agent is not owned by this CacheableLookup instance');
+			}
+
+			agent.createConnection = agent[kCacheableLookupCreateConnection];
+
+			delete agent[kCacheableLookupCreateConnection];
+			delete agent[kCacheableLookupInstance];
+		}
+	}
+
+	updateInterfaceInfo() {
+		const {_iface} = this;
+
+		this._iface = getIfaceInfo();
+
+		if ((_iface.has4 && !this._iface.has4) || (_iface.has6 && !this._iface.has6)) {
+			this._cache.clear();
+		}
+	}
+
+	clear(hostname) {
+		if (hostname) {
+			this._cache.delete(hostname);
+			return;
+		}
+
+		this._cache.clear();
+	}
+}
+
+module.exports = CacheableLookup;
+module.exports.default = CacheableLookup;

package/.output/server/node_modules/cacheable-request/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "cacheable-request",
+  "version": "7.0.4",
+  "description": "Wrap native HTTP requests with RFC compliant cache support",
+  "license": "MIT",
+  "repository": "lukechilds/cacheable-request",
+  "author": "Luke Childs <lukechilds123@gmail.com> (http://lukechilds.co.uk)",
+  "main": "src/index.js",
+  "engines": {
+    "node": ">=8"
+  },
+  "scripts": {
+    "test": "xo && nyc ava",
+    "coverage": "nyc report --reporter=text-lcov | coveralls"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "HTTP",
+    "HTTPS",
+    "cache",
+    "caching",
+    "layer",
+    "cacheable",
+    "RFC 7234",
+    "RFC",
+    "7234",
+    "compliant"
+  ],
+  "dependencies": {
+    "clone-response": "^1.0.2",
+    "get-stream": "^5.1.0",
+    "http-cache-semantics": "^4.0.0",
+    "keyv": "^4.0.0",
+    "lowercase-keys": "^2.0.0",
+    "normalize-url": "^6.0.1",
+    "responselike": "^2.0.0"
+  },
+  "devDependencies": {
+    "@keyv/sqlite": "^2.0.0",
+    "ava": "^1.1.0",
+    "coveralls": "^3.0.0",
+    "create-test-server": "3.0.0",
+    "delay": "^4.0.0",
+    "eslint-config-xo-lukechilds": "^1.0.0",
+    "nyc": "^14.1.1",
+    "pify": "^4.0.0",
+    "sqlite3": "^4.0.2",
+    "this": "^1.0.2",
+    "xo": "^0.23.0"
+  },
+  "xo": {
+    "extends": "xo-lukechilds"
+  }
+}