hackmud-script-manager 0.19.1-7a27b63 → 0.19.1-8719c7d

package/README.md

@@ -1,7 +1,7 @@
 # Hackmud Script Manager
 Command made for [hackmud-environment](https://github.com/samualtnorman/hackmud-environment), which is a scripting environment for hackmud with minification, autocompletes / intellisense, and TypeScript support.
 
-Install with `npm install hackmud-script-manager -g` to make the `hsm` command available everywhere.
+Install with `npm install -g hackmud-script-manager` to make the `hsm` command available everywhere.
 
 ## Features
 - Minification

package/bin/hsm.js

@@ -12,7 +12,7 @@ import { pull } from "../pull.js"
 import { syncMacros } from "../syncMacros.js"
 import "@samual/lib/readDirectoryWithStats"
 import "@samual/lib/copyFilePersistent"
-const version = "0.19.1-7a27b63",
+const version = "0.19.1-8719c7d",
 	options = new Map(),
 	commands = [],
 	userColours = new Cache(user => {
@@ -280,7 +280,7 @@ switch (commands[0]) {
 				scriptUser =
 					"scripts" == basename(resolve(target, "..")) && "hackmud" == basename(resolve(target, "../../..")) ?
 						basename(resolve(target, "../.."))
-					:	"UNKNOWN",
+					:	void 0,
 				optionsHasNoMinify = options.has("no-minify")
 			if ((optionsHasNoMinify || options.has("skip-minify")) && options.has("mangle-names")) {
 				logError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.19.1-7a27b63",
+  "version": "0.19.1-8719c7d",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",

package/processScript/index.js

@@ -47,7 +47,7 @@ async function processScript(
 		uniqueID = Math.floor(Math.random() * 2 ** 52)
 			.toString(36)
 			.padStart(11, "0"),
-		scriptUser = "UNKNOWN",
+		scriptUser,
 		scriptName = "UNKNOWN",
 		filePath,
 		mangleNames = !1,

package/{src/processScript → processScript}/transform.d.ts

@@ -1,4 +1,5 @@
 import type { File } from "@babel/types";
+import type { LaxPartial } from "@samual/lib";
 export type TransformOptions = {
     /** 11 a-z 0-9 characters */ uniqueID: string;
     /** the user going to be hosting this script (or set to `true` if not yet known) */ scriptUser: string | true;
@@ -11,7 +12,7 @@ export type TransformOptions = {
   * @param file babel ast node representing a file containing preprocessed code
   * @param sourceCode the original untouched source code
   * @param options {@link TransformOptions details} */
-export declare function transform(file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }?: Partial<TransformOptions>): {
+export declare function transform(file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }?: LaxPartial<TransformOptions>): {
     file: File;
     seclevel: number;
 };

package/processScript/transform.js

@@ -24,7 +24,7 @@ const { default: traverse } = babelTraverse,
 function transform(
 	file,
 	sourceCode,
-	{ uniqueID = "00000000000", scriptUser = "UNKNOWN", scriptName = "UNKNOWN", seclevel = 4 } = {}
+	{ uniqueID = "00000000000", scriptUser, scriptName = "UNKNOWN", seclevel = 4 } = {}
 ) {
 	const topFunctionName = `_${uniqueID}_SCRIPT_`,
 		exports = new Map(),
@@ -42,9 +42,14 @@ function transform(
 	if (program.scope.hasGlobal("_BUILD_DATE"))
 		for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
 			referencePath.replaceWith(t.numericLiteral(Date.now()))
+	let uniqueIdScriptUserNeeded = !1
 	if (program.scope.hasGlobal("_SCRIPT_USER"))
 		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
-			referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
+			if (null == scriptUser) {
+				uniqueIdScriptUserNeeded = !0
+				referencePath.replaceWith(t.identifier(`_${uniqueID}_SCRIPT_USER_`))
+			} else
+				referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
 	if (program.scope.hasGlobal("_SCRIPT_NAME"))
 		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
 			referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueID}$SCRIPT_NAME$` : scriptName))
@@ -64,30 +69,30 @@ function transform(
 			const referencePath = FunctionReferencePaths[0]
 			assert(
 				"MemberExpression" == referencePath.parent.type,
-				"src/processScript/transform.ts:89:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"Identifier" == referencePath.parent.property.type,
-				"src/processScript/transform.ts:94:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:104:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"prototype" == referencePath.parent.property.name,
-				"src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:109:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
 		} else {
 			for (const referencePath of FunctionReferencePaths) {
 				assert(
 					"MemberExpression" == referencePath.parent.type,
-					"src/processScript/transform.ts:107:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"src/processScript/transform.ts:112:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:122:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"src/processScript/transform.ts:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:127:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				functionDotPrototypeIsReferencedMultipleTimes = !0
 				referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
@@ -123,12 +128,12 @@ function transform(
 	const neededDbMethodLets = new Set()
 	if (program.scope.hasGlobal("$db"))
 		for (const referencePath of getReferencePathsToGlobal("$db", program)) {
-			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:171:69")
-			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:172:72")
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:181:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:182:72")
 			const databaseOpMethodName = referencePath.parentPath.node.property.name
 			assert(
 				validDBMethods.includes(databaseOpMethodName),
-				`src/processScript/transform.ts:178:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+				`src/processScript/transform.ts:188:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath?.type)
 				referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
@@ -161,7 +166,7 @@ function transform(
 	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:225:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:235:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -171,7 +176,7 @@ function transform(
 	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:240:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:250:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -179,13 +184,13 @@ function transform(
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:254:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:264: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:260:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:270:51 ${specifier.type} is currently unsupported`
 			)
 			const exportedName =
 				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
@@ -261,6 +266,28 @@ function transform(
 		[t.identifier("context"), t.identifier("args")],
 		t.blockStatement([])
 	)
+	if (uniqueIdScriptUserNeeded) {
+		const mainFunctionParams = mainFunction.params
+		mainFunction.params = [t.restElement(t.identifier(`_${uniqueID}_PARAMS_`))]
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(t.arrayPattern(mainFunctionParams), t.identifier(`_${uniqueID}_PARAMS_`)),
+				t.variableDeclarator(
+					t.arrayPattern([t.identifier(`_${uniqueID}_SCRIPT_USER_`)]),
+					t.callExpression(
+						t.memberExpression(
+							t.memberExpression(
+								t.memberExpression(t.identifier(`_${uniqueID}_PARAMS_`), t.numericLiteral(0), !0),
+								t.identifier("this_script")
+							),
+							t.identifier("split")
+						),
+						[t.stringLiteral(".")]
+					)
+				)
+			])
+		)
+	}
 	program.node.body = [mainFunction]
 	if (globalBlock.body.length) {
 		;(exports.size || liveExports.size) &&
@@ -286,11 +313,11 @@ function transform(
 		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:370:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:404:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:374:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:408:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -305,9 +332,9 @@ function transform(
 						Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
 					) {
 						const binding = program.scope.getBinding(declarator.id.name)
-						assert(binding, "src/processScript/transform.ts:393:23")
+						assert(binding, "src/processScript/transform.ts:427:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:396:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:430:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -351,16 +378,16 @@ function transform(
 				} else globalBlockVariables.add(declarator.id.name)
 			} else if ("ClassDeclaration" == globalBlockStatement.type) {
 				program.scope.crawl()
-				assert(globalBlockStatement.id, "src/processScript/transform.ts:447:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:481: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:459:22")
+					assert(binding, "src/processScript/transform.ts:493:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:462:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:496:55")
 						referencePath.replaceWith(
 							t.memberExpression(
 								t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -527,7 +554,7 @@ function transform(
 				}
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:629:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:663:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -633,23 +660,23 @@ function transform(
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:743:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:777:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:745:81"
+				"src/processScript/transform.ts:779:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:746:83"
+				"src/processScript/transform.ts:780:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:750:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:784: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:755:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:789:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(