hackmud-script-manager 0.20.4-0e584dd → 0.20.4-1581594

package/processScript/transform.js

@@ -101,29 +101,29 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			functionDotPrototypeIsReferencedMultipleTimes = !0
 		}
 	}
-	const neededSubscriptLets = new Set()
+	const neededSubscriptLets = new Map()
 	let detectedSeclevel = 4
 	for (const fakeSubscriptObjectName of ["$fs", "$4s", "$s"])
-		program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName)
+		program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName, 4)
 	for (const fakeSubscriptObjectName of ["$hs", "$3s"])
 		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
 			detectedSeclevel = 3
-			processFakeSubscriptObject(fakeSubscriptObjectName)
+			processFakeSubscriptObject(fakeSubscriptObjectName, 3)
 		}
 	for (const fakeSubscriptObjectName of ["$ms", "$2s"])
 		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
 			detectedSeclevel = 2
-			processFakeSubscriptObject(fakeSubscriptObjectName)
+			processFakeSubscriptObject(fakeSubscriptObjectName, 2)
 		}
 	for (const fakeSubscriptObjectName of ["$ls", "$1s"])
 		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
 			detectedSeclevel = 1
-			processFakeSubscriptObject(fakeSubscriptObjectName)
+			processFakeSubscriptObject(fakeSubscriptObjectName, 1)
 		}
 	for (const fakeSubscriptObjectName of ["$ns", "$0s"])
 		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
 			detectedSeclevel = 0
-			processFakeSubscriptObject(fakeSubscriptObjectName)
+			processFakeSubscriptObject(fakeSubscriptObjectName, 0)
 		}
 	seclevel = Math.min(seclevel, detectedSeclevel)
 	const neededDbMethodLets = new Set()
@@ -157,9 +157,10 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("$FMCL"))
 		for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
 			referencePath.replaceWith(t.identifier(`$${uniqueId}$FMCL$`))
-	if (program.scope.hasGlobal("$G"))
+	let needG = program.scope.hasGlobal("$G")
+	if (needG)
 		for (const referencePath of getReferencePathsToGlobal("$G", program))
-			referencePath.replaceWith(t.identifier(`$${uniqueId}$GLOBAL$`))
+			referencePath.replaceWith(t.identifier(`_${uniqueId}_G_`))
 	if (program.scope.hasGlobal("_SECLEVEL"))
 		for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
 			referencePath.replaceWith(t.numericLiteral(seclevel))
@@ -167,7 +168,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("Object"))
 		for (const referencePath of getReferencePathsToGlobal("Object", program))
 			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
-				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:241:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:243:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -177,7 +178,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("console"))
 		for (const referencePath of getReferencePathsToGlobal("console", program))
 			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
-				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:256:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:258:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueId}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -185,13 +186,13 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:270:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:272:27 program is empty")
 	if ("ExportNamedDeclaration" == lastStatement.type) {
 		program.node.body.pop()
 		for (const specifier of lastStatement.specifiers) {
 			assert(
 				"ExportSpecifier" == specifier.type,
-				`src/processScript/transform.ts:276:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:278:51 ${specifier.type} is currently unsupported`
 			)
 			const exportedName =
 				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
@@ -314,11 +315,11 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 		let hoistedGlobalBlockFunctions = 0
 		for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
 			if ("VariableDeclaration" == globalBlockStatement.type) {
-				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:410:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:412:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:414:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:416:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -333,15 +334,16 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 						Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
 					) {
 						const binding = program.scope.getBinding(declarator.id.name)
-						assert(binding, "src/processScript/transform.ts:433:23")
+						assert(binding, "src/processScript/transform.ts:435:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:436:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:438:56")
 							referencePath.replaceWith(
 								t.memberExpression(
-									t.identifier(`$${uniqueId}$GLOBAL$`),
+									t.identifier(`_${uniqueId}_G_`),
 									t.identifier(referencePath.node.name)
 								)
 							)
+							needG = !0
 						}
 						for (const referencePath of binding.constantViolations)
 							if ("AssignmentExpression" == referencePath.node.type)
@@ -350,12 +352,13 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 										clearObject(node)
 										Object.assign(
 											node,
-											t.memberExpression(t.identifier(`$${uniqueId}$GLOBAL$`), t.identifier(name))
+											t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(name))
 										)
+										needG = !0
 									}
 						globalBlockPath.remove()
 						globalBlockStatementPath.remove()
-						declarator.init &&
+						if (declarator.init) {
 							globalBlock.body.splice(
 								globalBlockIndex,
 								0,
@@ -363,13 +366,15 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 									t.assignmentExpression(
 										"=",
 										t.memberExpression(
-											t.identifier(`$${uniqueId}$GLOBAL$`),
+											t.identifier(`_${uniqueId}_G_`),
 											t.identifier(declarator.id.name)
 										),
 										declarator.init
 									)
 								)
 							)
+							needG = !0
+						}
 					} else {
 						globalBlockPath.remove()
 						globalBlockStatementPath.remove()
@@ -379,22 +384,20 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				} else globalBlockVariables.add(declarator.id.name)
 			} else if ("ClassDeclaration" == globalBlockStatement.type) {
 				program.scope.crawl()
-				assert(globalBlockStatement.id, "src/processScript/transform.ts:487:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:495:37")
 				if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
 					globalBlock.body.splice(globalBlockIndex, 1)
 					const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
 						[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
 					program.scope.crawl()
 					const binding = program.scope.getBinding(globalBlockStatement.id.name)
-					assert(binding, "src/processScript/transform.ts:499:22")
+					assert(binding, "src/processScript/transform.ts:507:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:502:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:510:55")
 						referencePath.replaceWith(
-							t.memberExpression(
-								t.identifier(`$${uniqueId}$GLOBAL$`),
-								t.identifier(referencePath.node.name)
-							)
+							t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(referencePath.node.name))
 						)
+						needG = !0
 					}
 					globalBlockPath.remove()
 					globalBlockStatementPath.remove()
@@ -405,7 +408,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 							t.assignmentExpression(
 								"=",
 								t.memberExpression(
-									t.identifier(`$${uniqueId}$GLOBAL$`),
+									t.identifier(`_${uniqueId}_G_`),
 									t.identifier(globalBlockStatement.id.name)
 								),
 								t.classExpression(
@@ -417,6 +420,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 							)
 						)
 					)
+					needG = !0
 				}
 			}
 		if (program.scope.hasGlobal("_EXPORTS"))
@@ -522,12 +526,12 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 		mainFunction.body.body.unshift(
 			t.variableDeclaration(
 				"let",
-				[...neededSubscriptLets].map(name =>
+				[...neededSubscriptLets].map(([name, seclevel]) =>
 					t.variableDeclarator(
 						t.identifier(`_${uniqueId}_SUBSCRIPT_${name}_`),
 						t.arrowFunctionExpression(
 							[t.restElement(t.identifier("args"))],
-							t.callExpression(t.identifier(`$${uniqueId}$SUBSCRIPT$${name}$`), [
+							t.callExpression(t.identifier(`$${uniqueId}$${seclevel}$SUBSCRIPT$${name}$`), [
 								t.spreadElement(t.identifier("args"))
 							])
 						)
@@ -535,6 +539,12 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				)
 			)
 		)
+	needG &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(t.identifier(`_${uniqueId}_G_`), t.identifier(`$${uniqueId}$GLOBAL$`))
+			])
+		)
 	traverse(file, {
 		BlockStatement({ node: blockStatement }) {
 			for (const [index, functionDeclaration] of blockStatement.body.entries())
@@ -555,7 +565,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				}
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:669:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:688:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -631,7 +641,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(
@@ -659,36 +671,37 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			t.identifier("prototype")
 		)
 	}
-	function processFakeSubscriptObject(fakeSubscriptObjectName) {
+	function processFakeSubscriptObject(fakeSubscriptObjectName, seclevel) {
 		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:804:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:785:81"
+				"src/processScript/transform.ts:806:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:786:83"
+				"src/processScript/transform.ts:807: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:811: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:816:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(
 					t.identifier(
-						`$${uniqueId}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
+						`$${uniqueId}$${seclevel}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
 					)
 				)
 			else {
 				const name = `${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}`
 				referencePath.parentPath.parentPath.replaceWith(t.identifier(`_${uniqueId}_SUBSCRIPT_${name}_`))
-				neededSubscriptLets.add(name)
+				const maxSecLevel = Math.max(neededSubscriptLets.get(name) || 0, seclevel)
+				neededSubscriptLets.set(name, maxSecLevel)
 			}
 		}
 	}

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/watch.js

@@ -9,6 +9,7 @@ import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
 import { processScript } from "./processScript/index.js"
+import "path/posix"
 import "@babel/generator"
 import "@babel/parser"
 import "@babel/plugin-proposal-decorators"