hackmud-script-manager 0.20.4-398440f → 0.20.4-4605f71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.20.4-398440f",
+  "version": "0.20.4-4605f71",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",
@@ -20,7 +20,11 @@
   "homepage": "https://github.com/samualtnorman/hackmud-script-manager#readme",
   "bugs": "https://github.com/samualtnorman/hackmud-script-manager/issues",
   "license": "MIT",
-  "author": "Samual Norman",
+  "author": "Samual Norman <me@samual.uk> (https://samual.uk/)",
+  "contributors": [
+    "Daniel Swann (https://github.com/danswann)",
+    "Longboyy"
+  ],
   "main": "index.js",
   "repository": {
     "type": "git",

package/processScript/minify.js

@@ -136,7 +136,8 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		const promises = []
 		traverse(file, {
 			FunctionDeclaration(path) {
-				path.traverse({
+				const body = path.get("body")
+				body.traverse({
 					Function(path) {
 						"CallExpression" != path.parent.type && "callee" != path.parentKey && path.skip()
 					},
@@ -152,7 +153,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 							path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValues.push(o) - 1}_`))
 					}
 				})
-				path.traverse({
+				body.traverse({
 					TemplateLiteral(path) {
 						if ("TaggedTemplateExpression" == path.parent.type) return
 						const templateLiteral = path.node
@@ -172,7 +173,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 					},
 					MemberExpression({ node: memberExpression }) {
 						if (!memberExpression.computed) {
-							assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:259:62")
+							assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:261:62")
 							if (!(memberExpression.property.name.length < 3)) {
 								memberExpression.computed = !0
 								memberExpression.property = t.stringLiteral(memberExpression.property.name)
@@ -220,8 +221,10 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 						)
 					},
 					StringLiteral(path) {
-						path.node.value = replaceUnsafeStrings(uniqueId, path.node.value)
-						if (JSON.stringify(path.node.value).includes("\\u00") || path.toString().length < 4) return
+						if (JSON.stringify(path.node.value).includes("\\u00") || path.toString().length < 4) {
+							path.node.value = replaceUnsafeStrings(uniqueId, path.node.value)
+							return
+						}
 						"key" == path.parentKey && "ObjectProperty" == path.parent.type && (path.parent.computed = !0)
 						let jsonValueIndex = jsonValues.indexOf(path.node.value)
 						;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(path.node.value))
@@ -244,7 +247,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		})
 		await Promise.all(promises)
 		const functionDeclaration = file.program.body[0]
-		assert("FunctionDeclaration" == functionDeclaration.type, "src/processScript/minify.ts:363:61")
+		assert("FunctionDeclaration" == functionDeclaration.type, "src/processScript/minify.ts:366:61")
 		if (jsonValues.length) {
 			hasComment = !0
 			if (1 == jsonValues.length)
@@ -361,7 +364,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		)
 	}
 	if (1 == forceQuineCheats) return code
-	assert(scriptBeforeJSONValueReplacement, "src/processScript/minify.ts:494:43")
+	assert(scriptBeforeJSONValueReplacement, "src/processScript/minify.ts:497:43")
 	return (
 			countHackmudCharacters(scriptBeforeJSONValueReplacement) <=
 				countHackmudCharacters(code) + Number(hasComment)
@@ -377,7 +380,7 @@ function parseObjectExpression(node, o) {
 			"Identifier" == property.key.type ||
 				"NumericLiteral" == property.key.type ||
 				"StringLiteral" == property.key.type,
-			"src/processScript/minify.ts:516:4"
+			"src/processScript/minify.ts:519:4"
 		)
 		if ("ArrayExpression" == property.value.type) {
 			const childArray = []

package/processScript/transform.js

@@ -631,7 +631,9 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 		VariableDeclaration({ node: variableDeclaration }) {
 			"const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
 		},
-		ThisExpression: path => path.replaceWith(t.identifier("undefined")),
+		ThisExpression: path => {
+			path.replaceWith(t.identifier("undefined"))
+		},
 		BigIntLiteral(path) {
 			const bigIntAsNumber = Number(path.node.value)
 			path.replaceWith(
@@ -661,23 +663,23 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:783:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:785:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:785:81"
+				"src/processScript/transform.ts:787:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:786:83"
+				"src/processScript/transform.ts:788:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:790:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:792:8 invalid user "${referencePath.parent.property.name}" in subscript`
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
-				`src/processScript/transform.ts:795:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:797:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(

package/push.d.ts

@@ -18,6 +18,14 @@ export type PushOptions = LaxPartial<{
       */
     forceQuineCheats: boolean;
 }>;
+export declare class MissingSourceFolderError extends Error {
+}
+export declare class MissingHackmudFolderError extends Error {
+}
+export declare class NoUsersError extends Error {
+}
+export declare class NoScriptsError extends Error {
+}
 /** Push scripts from a source directory to the hackmud directory.
   *
   * Pushes files directly in the source folder to all users
@@ -25,4 +33,4 @@ export type PushOptions = LaxPartial<{
   * @param hackmudPath directory created by hackmud containing user data including scripts
   * @param options {@link PushOptions details}
   * @returns array of info on pushed scripts */
-export declare function push(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;
+export declare function push(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<MissingSourceFolderError | MissingHackmudFolderError | NoUsersError | NoScriptsError | Info[]>;

package/push.js

@@ -42,32 +42,54 @@ import "./processScript/preprocess.js"
 import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
+class MissingSourceFolderError extends Error {}
+Object.defineProperty(MissingSourceFolderError.prototype, "name", { value: "MissingSourceFolderError" })
+class MissingHackmudFolderError extends Error {}
+Object.defineProperty(MissingHackmudFolderError.prototype, "name", { value: "MissingHackmudFolderError" })
+class NoUsersError extends Error {}
+Object.defineProperty(NoUsersError.prototype, "name", { value: "NoUsersError" })
+class NoScriptsError extends Error {}
+Object.defineProperty(NoScriptsError.prototype, "name", { value: "NoScriptsError" })
 async function push(
 	sourcePath,
 	hackmudPath,
 	{ scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
 ) {
 	const [sourceFolder, hackmudFolder] = await Promise.all([
-			readDirectoryWithStats(sourcePath),
-			readDirectoryWithStats(hackmudPath)
-		]),
-		sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
+		readDirectoryWithStats(sourcePath).catch(error => {
+			if (error && "ENOENT" == error.code)
+				return new MissingSourceFolderError("There is no folder at " + sourcePath)
+			throw error
+		}),
+		readDirectoryWithStats(hackmudPath).catch(error => {
+			if (error && "ENOENT" == error.code)
+				return new MissingHackmudFolderError("There is no folder at " + hackmudPath)
+			throw error
+		})
+	])
+	if (sourceFolder instanceof Error) return sourceFolder
+	if (hackmudFolder instanceof Error) return hackmudFolder
+	const sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
 		allUsers = new Set([
 			...scripts
-				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:52:65"))
+				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:82:65"))
 				.filter(name => "*" != name),
 			...sourceFolderFolders.map(({ name }) => name),
 			...hackmudFolder.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
 			...hackmudFolder
 				.filter(({ stats, name }) => stats.isFile() && name.endsWith(".key"))
 				.map(({ name }) => name.slice(0, -4))
-		]),
-		usersToScriptsToPush = new Cache(_user => new Map()),
+		])
+	if (!allUsers.size)
+		return new NoUsersError(
+			"Could not find any users. Either provide the names of your users or log into a user in hackmud"
+		)
+	const usersToScriptsToPush = new Cache(_user => new Map()),
 		scriptNamesToUsers = new Cache(_scriptName => new Set())
 	for (const script of scripts) {
 		const [user, scriptName] = script.split(".")
-		assert(user, "src/push.ts:69:16")
-		assert(scriptName, "src/push.ts:70:22")
+		assert(user, "src/push.ts:105:16")
+		assert(scriptName, "src/push.ts:106:22")
 		"*" == user ? scriptNamesToUsers.set(scriptName, allUsers) : scriptNamesToUsers.get(scriptName).add(user)
 	}
 	const sourceFolderFiles = sourceFolder.filter(({ stats }) => stats.isFile()),
@@ -98,7 +120,7 @@ async function push(
 	for (const [scriptName, users] of scriptNamesToUsers)
 		for (const user of users)
 			if (!usersToScriptsToPush.get(user).has(scriptName))
-				throw Error(`Could not find script ${user}.${scriptName} to push`)
+				return new NoScriptsError(`Could not find script ${user}.${scriptName} to push`)
 	const pathsToUsers = new Cache(_path => new Set())
 	for (const [user, scriptsToPush] of usersToScriptsToPush)
 		for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
@@ -135,4 +157,4 @@ async function push(
 	)
 	return allInfo
 }
-export { push }
+export { MissingHackmudFolderError, MissingSourceFolderError, NoScriptsError, NoUsersError, push }

package/syncMacros.js

@@ -37,7 +37,7 @@ async function syncMacros(hackmudPath) {
 			macroFile += `${name}\n${macro}\n`
 			macrosSynced++
 		}
-	for (const user of users) writeFile(resolve(hackmudPath, user + ".macros"), macroFile)
+	await Promise.all(users.map(async user => writeFile(resolve(hackmudPath, user + ".macros"), macroFile)))
 	return { macrosSynced, usersSynced: users.length }
 }
 export { syncMacros }