hackmud-script-manager 0.13.0-a60a7a2 → 0.13.0-c461329

package/src/pull.ts

@@ -0,0 +1,16 @@
+import { copyFilePersistent } from "@samual/lib"
+import { resolve as resolvePath } from "path"
+
+/**
+ * Copies script from hackmud to local source folder.
+ *
+ * @param sourceFolderPath path to folder containing source files
+ * @param hackmudPath path to hackmud directory
+ * @param script script to pull in `user.name` format
+ */
+export async function pull(sourceFolderPath: string, hackmudPath: string, script: string) {
+	const [ user, name ] = script.split(".")
+	await copyFilePersistent(resolvePath(hackmudPath, user, "scripts", `${name}.js`), resolvePath(sourceFolderPath, user, `${name}.js`))
+}
+
+export default pull

package/src/push.ts

@@ -0,0 +1,314 @@
+import { countHackmudCharacters, DynamicMap, forEachParallel, writeFilePersistent } from "@samual/lib"
+import fs from "fs"
+import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
+import type { Info } from "."
+import { supportedExtensions } from "./constants.json"
+import processScript from "./processScript"
+
+const { readFile, readdir: readDirectory } = fs.promises
+
+interface PushOptions {
+	/**
+	 * array of scripts in the format `foo.bar`
+	 *
+	 * also accepts wild card e.g. `*.bar` or `foo.*`
+	 *
+	 * pushes everything by default
+	 */
+	scripts: string | string[]
+
+	/** callback when a script is pushed */
+	onPush: (info: Info) => void
+
+	/** whether to do the minify step (defaults to `true`) */
+	minify: boolean
+
+	/** whether to mangle function and class names (defaults to `false`) */
+	mangleNames: boolean
+}
+
+/**
+ * Push scripts from a source directory to the hackmud directory.
+ *
+ * Files directly in the source folder are pushed to all users
+ * @param sourceDirectory directory containing source code
+ * @param hackmudDirectory directory created by hackmud containing user data including scripts
+ * @param options {@link PushOptions details}
+ * @returns array of info on pushed scripts
+ */
+export async function push(
+	sourceDirectory: string,
+	hackmudDirectory: string,
+	{
+		scripts = "*.*",
+		onPush = (info: Info) => {},
+		minify = true,
+		mangleNames = false
+	}: Partial<PushOptions> = {}
+) {
+	if (typeof scripts == "string")
+		scripts = [ scripts ]
+
+	const scriptNamesByUser = new DynamicMap((user: string) => new Set<string>())
+	const wildScriptUsers = new Set<string>()
+	const wildUserScripts = new Set<string>()
+
+	let pushEverything = false
+
+	for (const fullScriptName of scripts) {
+		const [ user, scriptName ] = fullScriptName.split(".")
+
+		if (!user || user == "*") {
+			if (!scriptName || scriptName == "*")
+				pushEverything = true
+			else
+				wildUserScripts.add(scriptName)
+		} else if (!scriptName || scriptName == "*")
+			wildScriptUsers.add(user)
+		else
+			scriptNamesByUser.get(user).add(scriptName)
+	}
+
+	const usersByGlobalScriptsToPush = new DynamicMap((user: string) => new Set<string>())
+	const allInfo: Info[] = []
+	const scriptNamesAlreadyPushedByUser = new DynamicMap((user: string) => new Set<string>())
+
+	let sourceDirectoryDirents
+
+	// *.bar
+	if (wildUserScripts.size || pushEverything) {
+		const hackmudDirectoryDirents = await readDirectory(resolvePath(hackmudDirectory), { withFileTypes: true })
+
+		const allUsers = new Set([
+			...(sourceDirectoryDirents = await readDirectory(resolvePath(sourceDirectory), { withFileTypes: true }))
+				.filter(dirent => dirent.isDirectory())
+				.map(dirent => dirent.name),
+			...hackmudDirectoryDirents
+				.filter(dirent => dirent.isDirectory())
+				.map(dirent => dirent.name),
+			...hackmudDirectoryDirents
+				.filter(dirent => dirent.isFile() && getFileExtension(dirent.name) == ".key")
+				.map(dirent => dirent.name.slice(0, -4)),
+			...scriptNamesByUser.keys(),
+			...wildScriptUsers
+		])
+
+		if (pushEverything) {
+			for (const user of allUsers)
+				wildScriptUsers.add(user)
+		} else {
+			for (const user of allUsers) {
+				const scriptNames = scriptNamesByUser.get(user)
+
+				for (const scriptName of wildUserScripts)
+					scriptNames.add(scriptName)
+			}
+		}
+	}
+
+	// foo.*
+	await forEachParallel(wildScriptUsers, async user => {
+		await readDirectory(resolvePath(sourceDirectory, user), { withFileTypes: true }).then(async dirents => {
+			await forEachParallel(dirents, async dirent => {
+				const extension = getFileExtension(dirent.name)
+
+				if (dirent.isFile() && supportedExtensions.includes(extension)) {
+					const scriptName = getBaseName(dirent.name, extension)
+					const filePath = resolvePath(sourceDirectory, user, dirent.name)
+
+					const { srcLength, script: minifiedCode } = await processScript(
+						await readFile(filePath, { encoding: "utf-8" }),
+						{
+							minify,
+							scriptUser: user,
+							scriptName,
+							filePath,
+							mangleNames
+						}
+					)
+
+					const info: Info = {
+						file: `${user}/${dirent.name}`,
+						users: [ user ],
+						minLength: countHackmudCharacters(minifiedCode),
+						error: null,
+						srcLength
+					}
+
+					scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
+					allInfo.push(info)
+
+					await writeFilePersistent(resolvePath(hackmudDirectory, user, `scripts/${scriptName}.js`), minifiedCode)
+
+					onPush(info)
+				}
+			})
+		}, (error: NodeJS.ErrnoException) => {
+			if (error.code != "ENOENT")
+				throw error
+		})
+	})
+
+	// foo.bar
+	await forEachParallel(scriptNamesByUser, async ([ user, scripts ]) => {
+		if (wildScriptUsers.has(user))
+			return
+
+		await forEachParallel(scripts, async scriptName => {
+			let code
+			let fileName
+
+			let filePath!: string
+
+			for (const extension of supportedExtensions) {
+				try {
+					fileName = `${scriptName}${extension}`
+					code = await readFile(filePath = resolvePath(sourceDirectory, user, fileName), { encoding: "utf-8" })
+					break
+				} catch {}
+			}
+
+			if (code) {
+				const { srcLength, script: minifiedCode } = await processScript(
+					code,
+					{
+						minify,
+						scriptUser: user,
+						scriptName,
+						filePath,
+						mangleNames
+					}
+				)
+
+				const info: Info = {
+					file: `${user}/${fileName}`,
+					users: [ user ],
+					minLength: countHackmudCharacters(minifiedCode),
+					error: null,
+					srcLength
+				}
+
+				allInfo.push(info)
+
+				await writeFilePersistent(resolvePath(hackmudDirectory, user, "scripts", `${scriptName}.js`), minifiedCode)
+
+				onPush(info)
+			} else
+				usersByGlobalScriptsToPush.get(scriptName).add(user)
+		})
+	})
+
+	// foo.* (global)
+	if (wildScriptUsers.size) {
+		await forEachParallel(sourceDirectoryDirents || await readDirectory(resolvePath(sourceDirectory), { withFileTypes: true }), async dirent => {
+			const extension = getFileExtension(dirent.name)
+
+			if (!dirent.isFile() || !supportedExtensions.includes(extension))
+				return
+
+			const scriptName = getBaseName(dirent.name, extension)
+			const usersToPushTo = [ ...wildScriptUsers, ...usersByGlobalScriptsToPush.get(scriptName) ].filter(user => !scriptNamesAlreadyPushedByUser.get(user).has(scriptName))
+
+			if (!usersToPushTo.length)
+				return
+
+			const uniqueID = Math.floor(Math.random() * (2 ** 52)).toString(36).padStart(11, "0")
+			const filePath = resolvePath(sourceDirectory, dirent.name)
+
+			const { srcLength, script: minifiedCode } = await processScript(
+				await readFile(filePath, { encoding: "utf-8" }),
+				{
+					minify,
+					scriptUser: true,
+					scriptName,
+					uniqueID,
+					filePath,
+					mangleNames
+				}
+			)
+
+			const info: Info = {
+				file: dirent.name,
+				users: usersToPushTo,
+				minLength: countHackmudCharacters(minifiedCode),
+				error: null,
+				srcLength
+			}
+
+			await forEachParallel(usersToPushTo, user =>
+				writeFilePersistent(
+					resolvePath(
+						hackmudDirectory,
+						user,
+						`scripts/${scriptName}.js`
+					),
+					minifiedCode
+						.replace(new RegExp(`$${uniqueID}$SCRIPT_USER`, "g"), user)
+						.replace(new RegExp(`$${uniqueID}$FULL_SCRIPT_NAME`, "g"), `${user}.${scriptName}`)
+				)
+			)
+
+			allInfo.push(info)
+			onPush(info)
+		})
+	} else {
+		// foo.bar (global)
+		await forEachParallel(usersByGlobalScriptsToPush, async ([ scriptName, users ]) => {
+			let code
+			let fileName!: string
+			let filePath!: string
+
+			for (const extension of supportedExtensions) {
+				try {
+					fileName = `${scriptName}${extension}`
+					code = await readFile(filePath = resolvePath(sourceDirectory, fileName), { encoding: "utf-8" })
+					break
+				} catch {}
+			}
+
+			if (code) {
+				const uniqueID = Math.floor(Math.random() * (2 ** 52)).toString(36).padStart(11, "0")
+
+				const { srcLength, script: minifiedCode } = await processScript(
+					code,
+					{
+						minify,
+						scriptUser: true,
+						scriptName,
+						uniqueID,
+						filePath,
+						mangleNames
+					}
+				)
+
+				const info: Info = {
+					file: fileName,
+					users: [ ...users ],
+					minLength: countHackmudCharacters(minifiedCode),
+					error: null,
+					srcLength
+				}
+
+				await forEachParallel(users, user =>
+					writeFilePersistent(
+						resolvePath(
+							hackmudDirectory,
+							user,
+							`scripts/${scriptName}.js`
+						),
+						minifiedCode
+							.replace(new RegExp(`$${uniqueID}$SCRIPT_USER`, "g"), user)
+							.replace(new RegExp(`$${uniqueID}$FULL_SCRIPT_NAME`, "g"), `${user}.${scriptName}`)
+					)
+				)
+
+				allInfo.push(info)
+				onPush(info)
+			}
+		})
+	}
+
+	return allInfo
+}
+
+export default push

package/src/syncMacros.ts

@@ -0,0 +1,52 @@
+import fs from "fs"
+import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
+
+const { readFile, readdir: readDirectory, stat: getFileStatus, writeFile } = fs.promises
+
+export async function syncMacros(hackmudPath: string) {
+	const files = await readDirectory(hackmudPath, { withFileTypes: true })
+	const macros = new Map<string, { macro: string, date: Date }>()
+	const users: string[] = []
+
+	for (const file of files) {
+		if (!file.isFile())
+			continue
+
+		switch (getFileExtension(file.name)) {
+			case ".macros": {
+				const lines = (await readFile(resolvePath(hackmudPath, file.name), { encoding: "utf-8" })).split("\n")
+				const date = (await getFileStatus(resolvePath(hackmudPath, file.name))).mtime
+
+				for (let i = 0; i < lines.length / 2 - 1; i++) {
+					const macroName = lines[i * 2]
+					const curMacro = macros.get(macroName)
+
+					if (!curMacro || date > curMacro.date)
+						macros.set(macroName, { date, macro: lines[i * 2 + 1] })
+				}
+			} break
+
+			case ".key": {
+				users.push(getBaseName(file.name, ".key"))
+			} break
+		}
+	}
+
+	let macroFile = ""
+	let macrosSynced = 0
+
+	for (const [ name, { macro } ] of [ ...macros ].sort(([ a ], [ b ]) => (a as any > b as any) - (a as any < b as any))) {
+		if (macro[0] != macro[0].toLowerCase())
+			continue
+
+		macroFile += `${name}\n${macro}\n`
+		macrosSynced++
+	}
+
+	for (const user of users)
+		writeFile(resolvePath(hackmudPath, user + ".macros"), macroFile)
+
+	return { macrosSynced, usersSynced: users.length }
+}
+
+export default syncMacros

package/src/test.ts

@@ -0,0 +1,59 @@
+import fs from "fs"
+import { extname as getFileExtension, resolve as resolvePath } from "path"
+import { supportedExtensions } from "./constants.json"
+import processScript from "./processScript"
+
+const { readFile, readdir: readDirectory } = fs.promises
+
+export async function test(srcPath: string) {
+	const promises: Promise<any>[] = []
+
+	const errors: {
+		file: string
+		message: string
+		line: number
+	}[] = []
+
+	for (const dirent of await readDirectory(srcPath, { withFileTypes: true })) {
+		if (dirent.isDirectory()) {
+			promises.push(readDirectory(resolvePath(srcPath, dirent.name), { withFileTypes: true }).then(files => {
+				const promises: Promise<any>[] = []
+
+				for (const file of files) {
+					if (!file.isFile() || !supportedExtensions.includes(getFileExtension(file.name)))
+						continue
+
+					promises.push(
+						readFile(resolvePath(srcPath, dirent.name, file.name), { encoding: "utf-8" })
+							.then(processScript)
+							.then(({ warnings }) =>
+								errors.push(...warnings.map(({ message, line }) => ({
+									file: `${dirent.name}/${file.name}`,
+									message, line
+								})))
+							)
+					)
+				}
+
+				return Promise.all(promises)
+			}))
+		} else if (dirent.isFile() && supportedExtensions.includes(getFileExtension(dirent.name))) {
+			promises.push(
+				readFile(resolvePath(srcPath, dirent.name), { encoding: "utf-8" })
+					.then(processScript)
+					.then(({ warnings }) =>
+						errors.push(...warnings.map(({ message, line }) => ({
+							file: dirent.name,
+							message, line
+						})))
+					)
+			)
+		}
+	}
+
+	await Promise.all(promises)
+
+	return errors
+}
+
+export default test

package/src/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"compilerOptions": {
+		"target": "ES2019", /* ES2019 is oldest properly supported ES version in Node 12 which is the oldest currently supported Node version */
+		"module": "ES2020",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"declaration": true,
+		"outDir": "../dist",
+		"useUnknownInCatchVariables": true,
+		"exactOptionalPropertyTypes": true,
+		"noImplicitOverride": true,
+		"moduleResolution": "Node",
+		"resolveJsonModule": true,
+		"emitDeclarationOnly": true
+	},
+	"exclude": [ "bin" ],
+	"references": [ { "path": ".." } ]
+}

package/src/watch.ts

@@ -0,0 +1,156 @@
+import { countHackmudCharacters, writeFilePersistent } from "@samual/lib"
+import { watch as watchDirectory } from "chokidar"
+import fs from "fs"
+import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
+import type { Info } from "."
+import { supportedExtensions } from "./constants.json"
+import generateTypings from "./generateTypings"
+import processScript from "./processScript"
+
+const { readFile, readdir: readDirectory } = fs.promises
+
+/**
+ * Watches target file or folder for updates and builds and pushes updated file.
+ *
+ * @param srcDir path to folder containing source files
+ * @param hackmudDir path to hackmud directory
+ * @param users users to push to (pushes to all if empty)
+ * @param scripts scripts to push from (pushes from all if empty)
+ * @param onPush function that's called after each script has been built and written
+ */
+export function watch(srcDir: string, hackmudDir: string, users: string[], scripts: string[], onPush?: (info: Info) => void, { genTypes }: { genTypes?: string | undefined } = {}) {
+	const watcher = watchDirectory("", { depth: 1, cwd: srcDir, awaitWriteFinish: { stabilityThreshold: 100 } }).on("change", async path => {
+		const extension = getFileExtension(path)
+
+		if (supportedExtensions.includes(extension)) {
+			const name = getBaseName(path, extension)
+			const fileName = getBaseName(path)
+
+			if (path == fileName) {
+				if (!scripts.length || scripts.includes(name)) {
+					const sourceCode = await readFile(resolvePath(srcDir, path), { encoding: "utf-8" })
+					const skips = new Map<string, string[]>()
+					const promisesSkips: Promise<any>[] = []
+
+					for (const dir of await readDirectory(srcDir, { withFileTypes: true })) {
+						if (!dir.isDirectory())
+							continue
+
+						promisesSkips.push(readDirectory(resolvePath(srcDir, dir.name), { withFileTypes: true }).then(files => {
+							for (const file of files) {
+								if (!file.isFile())
+									continue
+
+								const fileExtension = getFileExtension(file.name)
+
+								if (!supportedExtensions.includes(fileExtension))
+									continue
+
+								const name = getBaseName(file.name, fileExtension)
+								const skip = skips.get(name)
+
+								if (skip)
+									skip.push(dir.name)
+								else
+									skips.set(name, [ dir.name ])
+							}
+						}))
+					}
+
+					await Promise.all(promisesSkips)
+
+					let error = null
+
+					const { script, srcLength } = await processScript(sourceCode).catch(reason => {
+						error = reason
+
+						return {
+							script: "",
+							srcLength: 0
+						}
+					})
+
+					const info: Info = {
+						file: path,
+						users: [],
+						minLength: 0,
+						error,
+						srcLength
+					}
+
+					const promises: Promise<any>[] = []
+
+					if (!error) {
+						if (script) {
+							const skip = skips.get(name) || []
+
+							info.minLength = countHackmudCharacters(script)
+
+							if (!users.length) {
+								users = (await readDirectory(hackmudDir, { withFileTypes: true }))
+									.filter(a => a.isFile() && getFileExtension(a.name) == ".key")
+									.map(a => getBaseName(a.name, ".key"))
+							}
+
+							for (const user of users) {
+								if (skip.includes(user))
+									continue
+
+								info.users.push(user)
+								promises.push(writeFilePersistent(resolvePath(hackmudDir, user, "scripts", `${name}.js`), script))
+							}
+						} else
+							info.error = new Error("processed script was empty")
+					}
+
+					if (onPush) {
+						await Promise.all(promises)
+						onPush(info)
+					}
+				}
+			} else {
+				const user = getBaseName(resolvePath(path, ".."))
+
+				if ((!users.length || users.includes(user)) && (!scripts.length || scripts.includes(name))) {
+					const sourceCode = await readFile(resolvePath(srcDir, path), { encoding: "utf-8" })
+					let error = null
+
+					const { script, srcLength } = await processScript(sourceCode).catch(reason => {
+						error = reason
+
+						return {
+							script: "",
+							srcLength: 0
+						}
+					})
+
+					const info: Info = {
+						file: path,
+						users: [ user ],
+						minLength: 0,
+						error,
+						srcLength
+					}
+
+					if (!error) {
+						if (script) {
+							info.minLength = countHackmudCharacters(script)
+							await writeFilePersistent(resolvePath(hackmudDir, user, "scripts", `${name}.js`), script)
+						} else
+							info.error = new Error("processed script was empty")
+					}
+
+					onPush?.(info)
+				}
+			}
+		}
+	})
+
+	if (genTypes) {
+		generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir)
+		watcher.on("add", () => generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir))
+		watcher.on("unlink", () => generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir))
+	}
+}
+
+export default watch

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"compilerOptions": {
+		"rootDir": ".",
+		"outDir": ".",
+		"resolveJsonModule": true,
+		"composite": true,
+		"emitDeclarationOnly": true,
+		"skipLibCheck": true
+	},
+	"files": [ "package.json" ],
+	"exclude": [ "src" ]
+}

package/assert-1b7dada8.js

@@ -1 +0,0 @@
-class CustomError extends Error{constructor(...r){super(...r),function _defineProperty(r,e,s){return e in r?Object.defineProperty(r,e,{value:s,enumerable:!0,configurable:!0,writable:!0}):r[e]=s,r}(this,"name",this.constructor.name)}}class AssertError extends CustomError{}function assert(r,e="assertion failed"){if(!r)throw new AssertError(e)}function ensure(r,e="ensure failed"){return assert(r,e),r}export{assert as a,ensure as e};

package/bin/hsm.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/bin/hsm.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import o from"fs";import{resolve as e,basename as s,extname as t,dirname as r,relative as n}from"path";import{D as i,s as a,w as l,t as c,a as p,push as g}from"../push.js";import{g as b}from"../processScript/minify.js";import m from"chalk";import{homedir as u}from"os";import{processScript as f}from"../processScript/index.js";import{generateTypings as d}from"../generateTypings.js";import{syncMacros as h}from"../syncMacros.js";import{pull as k}from"../pull.js";import"chokidar";import"@babel/generator";import"@babel/parser";import"@babel/traverse";import"@babel/types";import"../assert-1b7dada8.js";import"../spliceString-2c6f214f.js";import"acorn";import"terser";import"perf_hooks";import"../processScript/compile.js";import"@babel/core";import"@babel/plugin-proposal-class-properties";import"@babel/plugin-proposal-class-static-block";import"@babel/plugin-proposal-decorators";import"@babel/plugin-proposal-do-expressions";import"@babel/plugin-proposal-function-bind";import"@babel/plugin-proposal-function-sent";import"@babel/plugin-proposal-json-strings";import"@babel/plugin-proposal-logical-assignment-operators";import"@babel/plugin-proposal-nullish-coalescing-operator";import"@babel/plugin-proposal-numeric-separator";import"@babel/plugin-proposal-object-rest-spread";import"@babel/plugin-proposal-optional-catch-binding";import"@babel/plugin-proposal-optional-chaining";import"@babel/plugin-proposal-partial-application";import"@babel/plugin-proposal-pipeline-operator";import"@babel/plugin-proposal-private-property-in-object";import"@babel/plugin-proposal-record-and-tuple";import"@babel/plugin-proposal-throw-expressions";import"@babel/plugin-transform-exponentiation-operator";import"@babel/plugin-transform-typescript";import"../processScript/postProcess.js";import"../processScript/preProcess.js";const{readFile:w,rmdir:y,writeFile:$,mkdir:j}=o.promises,v=e(u(),".config"),P=e(v,"hsm.json"),S=new Map,C=[];let x;const N=m.rgb(255,244,4),O=m.rgb(243,249,152),L=m.rgb(179,255,155),T=m.rgb(255,150,224),E=m.rgb(30,255,0),I=m.rgb(202,202,202),M=new i((o=>{let e=0;for(const s of o)e+=(e>>1)+e+"xi1_8ratvsw9hlbgm02y5zpdcn7uekof463qj".indexOf(s)+1;return[N,O,L,T,E,I][e%6](o)}));for(const o of process.argv.slice(2))if("-"==o[0]){const[e,s]=o.split("=");let t=s;if(t)if("true"==t)t=!0;else if("false"==t)t=!1;else{const o=Number(t);isFinite(o)&&(t=o)}else t=!0;if("-"==o[1])S.set(e.slice(2),t);else for(const o of e.slice(1))S.set(o,t)}else C.push(o);function help(){switch(C[0]){case"config":switch(C[1]){case"get":console.log("hsm config get <key>");break;case"set":console.log("hsm config set <key> <value>");break;case"delete":console.log("hsm config delete <key>");break;default:console.log("hsm config <get, delete, set>")}break;case"push":console.log('hsm push [<dir> [..."<script user>.<script name>"]]');break;case"watch":console.log("hsm watch [dir]");break;case"pull":console.log("hsm pull <script user>.<script name>");break;case"minify":case"golf":console.log(`${s(process.argv[1])} ${C[0]} <target> [output]`);break;default:console.log("hsm <push, watch, pull, config, golf>")}}async function version(){console.log("0.13.0-a60a7a2")}async function getConfig(){return x||(x=await w(P,{encoding:"utf-8"}).then((o=>{let e;try{e=JSON.parse(o)}catch{return console.log("config file was corrupted, resetting"),{}}return e&&"object"==typeof e?e:(console.log("config file was corrupted, resetting"),{})}),(()=>(console.log(`creating config file at ${P}`),{}))))}function exploreObject(o,e,s=!1){for(const r of e){var t;o=s?"object"==typeof o[r]?o[r]:o[r]={}:null===(t=o)||void 0===t?void 0:t[r]}return o}function updateConfig(){if(x){const o=JSON.stringify(x);$(P,o).catch((async e=>{switch(e.code){case"EISDIR":await y(P);break;case"ENOENT":await j(v);break;default:throw e}$(P,o)}))}}function onPushLogger({file:o,users:r,srcLength:n,minLength:i,error:a}){r.length&&(a?console.log(`error "${m.bold(a.message)}" in ${m.bold(o)}`):console.log(`pushed ${m.bold(o)} to ${r.map((o=>m.bold(M.get(o)))).join(", ")} | ${m.bold(String(i))} chars from ${m.bold(String(n))} | saved ${m.bold(String(n-i))} (${m.bold(`${Math.round(100*(1-i/n))}%`)}) | ${m.bold(`${e(x.hackmudPath,r[0],"scripts",s(o,t(o)))}.js`)}`))}(async()=>{if(S.get("version")||S.get("v"))version();else if(S.get("help")||S.get("h"))help();else{switch(C[0]){case"push":{const o=await getConfig();if(!o.hackmudPath){console.log("you need to set hackmudPath in config before you can use this command");break}const e=C[1]||".",s=o.hackmudPath,t=C.slice(2);t.length||t.push("*.*");(await g(e,s,{scripts:t,onPush:onPushLogger,minify:!S.get("skip-minify")})).length||console.warn("couldn't find any scripts to push"),updateConfig()}break;case"dev":case"watch":{var o,i,u;const e=await getConfig();if(!e.hackmudPath){console.log("you need to set hackmudPath in config before you can use this command");break}const s=C[1]||".",t=e.hackmudPath,r=(null===(o=S.get("users"))||void 0===o?void 0:o.toString().split(","))||[],n=(null===(i=S.get("scripts"))||void 0===i?void 0:i.toString().split(","))||[],a=null===(u=S.get("gen-types"))||void 0===u?void 0:u.toString();p(s,t,r,n,onPushLogger,{genTypes:a})}break;case"pull":{const o=await getConfig();if(!o.hackmudPath){console.log("you need to set hackmudPath in config before you can use this command");break}const e=C[1];if(!e){help();break}const s=C[2]||".",t=o.hackmudPath;try{await k(s,t,e)}catch(o){console.log("something went wrong, did you forget to #down the script?")}}break;case"sync-macros":{const{hackmudPath:o}=await getConfig();if(!o){console.log("you need to set hackmudPath in config before you can use this command");break}const{macrosSynced:e,usersSynced:s}=await h(o);console.log(`synced ${e} macros to ${s} users`)}break;case"test":{const o=e(C[1]||".");let s=0;console.log(`testing scripts in ${m.bold(o)}\n`);for(const{file:e,line:t,message:r}of await c(o))console.log(`error "${m.bold(r)}" in ${m.bold(e)} on line ${m.bold(String(t))}`),s++;if(!s){console.log("no errors found");break}if(s){process.exitCode=1,console.log(`\nencountered ${m.bold(String(s))} errors`);break}console.log("no errors found")}break;case"gen-types":{const o=e(C[1]||".");let s;s=C[2]?e(C[2]):e(o,"../player.d.ts"),d(o,s,(await getConfig()).hackmudPath)}break;case"config":switch(C[1]){case"get":console.log(exploreObject(await getConfig(),C[2].split(".")));break;case"delete":{var y;const o=C[2].split(".");if(!o.length){help();break}const e=await getConfig();null===(y=exploreObject(e,o))||void 0===y||delete y[C[3]],console.log(e)}break;case"set":{const o=C[2].split(".");if(!o.length){help();break}const s=await getConfig();let t=s;for(let e of o.slice(0,-1))t="object"==typeof t[e]?t[e]:t[e]={};t[o.slice(-1)[0]]=C[3],s.hackmudPath&&(s.hackmudPath=e(s.hackmudPath)),console.log(s)}break;default:C[1]&&console.log("unknown command"),help()}break;case"help":case"h":help();break;case"version":case"v":version();break;case"golf":case"minify":{if(!C[1]){console.log(`Target required\nUsage: ${s(process.argv[1])} ${C[0]} <target> [output]`);break}const o=t(C[1]);if(!a.includes(o)){console.log(`Unsupported file extension "${m.bold(o)}"\nSupported extensions are "${a.map((o=>m.bold(o))).join('", "')}"`);break}await w(C[1],{encoding:"utf-8"}).then((async t=>{const i=s(C[1],o),a=i.endsWith(".src"),c=a?i.slice(0,-4):i;let p="UNKNOWN";"scripts"==s(e(C[1],".."))&&"hackmud"==s(e(C[1],"../../.."))&&(p=s(e(C[1],"../..")));const{script:g,srcLength:u,warnings:d,timeTook:h}=await f(t,{minify:!S.get("skip-minify"),scriptUser:p,scriptName:c});for(const{message:o,line:e}of d)console.log(`warning "${m.bold(o)}" on line ${m.bold(String(e))}`);let k;k=C[2]?C[2]:e(r(C[1]),a?`${c}.js`:".js"==o?`${i}.min.js`:`${i}.js`);const w=b(g);await l(k,g).catch((async t=>{if(!C[2]||"EISDIR"!=t.code)throw t;k=e(k,`${s(C[1],o)}.js`),await l(k,g)})).then((()=>console.log(`wrote ${m.bold(w)} chars to ${m.bold(n(".",k))} | saved ${m.bold(u-w)} chars | took ${Math.round(100*h)/100}ms`)),(o=>console.log(o.message)))}),(o=>console.log(o.message)))}break;default:C[0]&&console.log("unknown command"),help()}updateConfig()}})();

package/generateTypings.d.ts

@@ -1,2 +0,0 @@
-export declare function generateTypings(srcDir: string, target: string, hackmudPath?: string): Promise<void>;
-export default generateTypings;

package/generateTypings.js

@@ -1 +0,0 @@
-import{promises as t}from"fs";import{extname as e,basename as n,resolve as s}from"path";const{readdir:r,writeFile:o}=t;async function generateTypings(t,a,i){const f=new Set;if(i)for(const t of await r(i,{withFileTypes:!0}))t.isFile()&&".key"==e(t.name)&&f.add(n(t.name,".key"));const c=[],l=[],p={},m={};for(const o of await r(t,{withFileTypes:!0}))if(o.isFile())".ts"==e(o.name)?c.push(n(o.name,".ts")):".js"==e(o.name)&&l.push(n(o.name,".js"));else if(o.isDirectory()){const a=p[o.name]=[],i=m[o.name]=[];f.add(o.name);for(const f of await r(s(t,o.name),{withFileTypes:!0}))f.isFile()&&(".ts"==e(f.name)?a.push(n(f.name,".ts")):".js"==e(f.name)&&i.push(n(f.name,".js")))}let y="";for(const t of c)y+=`import { script as $${t}$ } from "./src/${t}"\n`;y+="\n";for(const t in p){const e=p[t];for(const n of e)y+=`import { script as $${t}$${n}$ } from "./src/${t}/${n}"\n`}y+="\ntype ArrayRemoveFirst<A> = A extends [ infer FirstItem, ...infer Rest ] ? Rest : never\n\ntype Subscript<T extends (...args: any) => any> =\n\t(...args: ArrayRemoveFirst<Parameters<T>>) => ReturnType<T> | ScriptFailure\n\ntype WildFullsec = Record<string, () => ScriptFailure> & {\n";for(const t of c)y+=`\t${t}: Subscript<typeof $${t}$>\n`;for(const t of l)y+=`\t${t}: (...args: any) => any\n`;y+="}\n\ndeclare global {\n\tinterface PlayerFullsec {";let $=!0;for(const t of f){const e=p[t],n=m[t];if(e&&e.length||n&&n.length){$=!0,y+=`\n\t\t${t}: WildFullsec & {\n`;for(const n of e)y+=`\t\t\t${n}: Subscript<typeof $${t}$${n}$>\n`;for(const t of n)y+=`\t\t\t${t}: (...args: any) => any\n`;y+="\t\t}"}else $&&(y+="\n",$=!1),y+=`\t\t${t}: WildFullsec`;y+="\n"}y+="\t}\n}\n",await o(a,y)}export{generateTypings as default,generateTypings};

package/index.d.ts

@@ -1,15 +0,0 @@
-export interface Info {
-    file: string;
-    users: string[];
-    srcLength: number;
-    minLength: number;
-    error: Error | null;
-}
-export declare const supportedExtensions: string[];
-export { generateTypings } from "./generateTypings";
-export { processScript } from "./processScript";
-export { pull } from "./pull";
-export { push } from "./push";
-export { syncMacros } from "./syncMacros";
-export { test } from "./test";
-export { watch } from "./watch";