hackmud-script-manager 0.20.4-550e28d → 0.20.4-6815ce0

package/index.js

@@ -46,7 +46,7 @@ import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
 import "@samual/lib/copyFilePersistent"
-import "@samual/lib/Cache"
+import "@samual/lib/AutoMap"
 import "@samual/lib/writeFilePersistent"
 import "fs/promises"
 import "chokidar"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.20.4-550e28d",
+  "version": "0.20.4-6815ce0",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",
@@ -31,50 +31,50 @@
     "url": "https://github.com/samualtnorman/hackmud-script-manager.git"
   },
   "dependencies": {
-    "@babel/generator": "^7.24.4",
-    "@babel/parser": "^7.24.4",
-    "@babel/plugin-proposal-decorators": "^7.24.1",
-    "@babel/plugin-proposal-destructuring-private": "^7.24.1",
-    "@babel/plugin-proposal-do-expressions": "^7.24.1",
-    "@babel/plugin-proposal-explicit-resource-management": "^7.24.1",
-    "@babel/plugin-proposal-function-bind": "^7.24.1",
-    "@babel/plugin-proposal-function-sent": "^7.24.1",
-    "@babel/plugin-proposal-partial-application": "^7.24.1",
-    "@babel/plugin-proposal-pipeline-operator": "^7.24.1",
-    "@babel/plugin-proposal-record-and-tuple": "^7.24.1",
-    "@babel/plugin-proposal-throw-expressions": "^7.24.1",
-    "@babel/plugin-transform-class-properties": "^7.24.1",
-    "@babel/plugin-transform-class-static-block": "^7.24.4",
-    "@babel/plugin-transform-exponentiation-operator": "^7.24.1",
-    "@babel/plugin-transform-json-strings": "^7.24.1",
-    "@babel/plugin-transform-logical-assignment-operators": "^7.24.1",
-    "@babel/plugin-transform-nullish-coalescing-operator": "^7.24.1",
-    "@babel/plugin-transform-numeric-separator": "^7.24.1",
-    "@babel/plugin-transform-object-rest-spread": "^7.24.1",
-    "@babel/plugin-transform-optional-catch-binding": "^7.24.1",
-    "@babel/plugin-transform-optional-chaining": "^7.24.1",
-    "@babel/plugin-transform-private-property-in-object": "^7.24.1",
-    "@babel/plugin-transform-typescript": "^7.24.4",
-    "@babel/plugin-transform-unicode-sets-regex": "^7.24.1",
-    "@babel/traverse": "^7.24.1",
-    "@babel/types": "^7.24.0",
+    "@babel/generator": "^7.26.2",
+    "@babel/parser": "^7.26.2",
+    "@babel/plugin-proposal-decorators": "^7.25.9",
+    "@babel/plugin-proposal-destructuring-private": "^7.26.0",
+    "@babel/plugin-proposal-do-expressions": "^7.25.9",
+    "@babel/plugin-proposal-explicit-resource-management": "^7.25.9",
+    "@babel/plugin-proposal-function-bind": "^7.25.9",
+    "@babel/plugin-proposal-function-sent": "^7.25.9",
+    "@babel/plugin-proposal-partial-application": "^7.25.9",
+    "@babel/plugin-proposal-pipeline-operator": "^7.25.9",
+    "@babel/plugin-proposal-record-and-tuple": "^7.25.9",
+    "@babel/plugin-proposal-throw-expressions": "^7.25.9",
+    "@babel/plugin-transform-class-properties": "^7.25.9",
+    "@babel/plugin-transform-class-static-block": "^7.26.0",
+    "@babel/plugin-transform-exponentiation-operator": "^7.25.9",
+    "@babel/plugin-transform-json-strings": "^7.25.9",
+    "@babel/plugin-transform-logical-assignment-operators": "^7.25.9",
+    "@babel/plugin-transform-nullish-coalescing-operator": "^7.25.9",
+    "@babel/plugin-transform-numeric-separator": "^7.25.9",
+    "@babel/plugin-transform-object-rest-spread": "^7.25.9",
+    "@babel/plugin-transform-optional-catch-binding": "^7.25.9",
+    "@babel/plugin-transform-optional-chaining": "^7.25.9",
+    "@babel/plugin-transform-private-property-in-object": "^7.25.9",
+    "@babel/plugin-transform-typescript": "^7.25.9",
+    "@babel/plugin-transform-unicode-sets-regex": "^7.25.9",
+    "@babel/traverse": "^7.25.9",
+    "@babel/types": "^7.26.0",
     "@bloomberg/record-tuple-polyfill": "^0.0.4",
     "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-commonjs": "^28.0.1",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@samual/lib": "0.11.0",
-    "acorn": "^8.11.3",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@samual/lib": "^0.13.0",
+    "acorn": "^8.14.0",
     "chalk": "^5.3.0",
-    "chokidar": "^3.6.0",
-    "import-meta-resolve": "^4.0.0",
-    "prettier": "^3.2.5",
+    "chokidar": "^4.0.1",
+    "import-meta-resolve": "^4.1.0",
+    "prettier": "^3.3.3",
     "proxy-polyfill": "^0.3.2",
-    "rollup": "^4.16.4",
-    "terser": "^5.30.4"
+    "rollup": "^4.27.4",
+    "terser": "^5.36.0"
   },
   "peerDependencies": {
-    "typescript": "5.4.5"
+    "typescript": "^5.4.5"
   },
   "type": "module",
   "exports": {

package/processScript/index.js

@@ -204,6 +204,7 @@ async function processScript(
 	const bundle = await rollup({
 			input: filePathResolved,
 			plugins: [
+				rollupPluginJSON({ preferConst: !0 }),
 				{
 					name: "hackmud-script-manager",
 					async transform(code, id) {
@@ -227,8 +228,7 @@ async function processScript(
 				},
 				babel({ babelHelpers: "bundled", plugins, configFile: !1, extensions: supportedExtensions }),
 				rollupPluginCommonJS(),
-				rollupPluginNodeResolve({ extensions: supportedExtensions }),
-				rollupPluginJSON()
+				rollupPluginNodeResolve({ extensions: supportedExtensions })
 			],
 			treeshake: { moduleSideEffects: !1 }
 		}),

package/processScript/transform.js

@@ -162,21 +162,25 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	if (program.scope.hasGlobal("_SECLEVEL"))
 		for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
 			referencePath.replaceWith(t.numericLiteral(seclevel))
-	let needGetPrototypeOf = !1
+	let needGetPrototypeOf = !1,
+		needHasOwn = !1
 	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:242:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
+				} else if ("hasOwn" == referencePath.parent.property.name) {
+					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_HAS_OWN_`))
+					needHasOwn = !0
 				}
 			}
 	const consoleMethodsReferenced = new Set()
 	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:260:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueId}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -184,13 +188,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:274: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:280:51 ${specifier.type} is currently unsupported`
 			)
 			if (
 				"default" !=
@@ -292,11 +296,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:390:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:394:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:394:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:398:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -311,9 +315,9 @@ 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:413:23")
+						assert(binding, "src/processScript/transform.ts:417:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:416:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:420:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`_${uniqueId}_G_`),
@@ -361,16 +365,16 @@ 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:473:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:477: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:485:22")
+					assert(binding, "src/processScript/transform.ts:489:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:488:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:492:55")
 						referencePath.replaceWith(
 							t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(referencePath.node.name))
 						)
@@ -448,6 +452,31 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				)
 			])
 		)
+	needHasOwn &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(
+					t.identifier(`_${uniqueId}_HAS_OWN_`),
+					t.callExpression(
+						t.memberExpression(
+							t.memberExpression(
+								t.identifier(
+									globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
+								),
+								t.identifier("call")
+							),
+							t.identifier("bind")
+						),
+						[
+							t.memberExpression(
+								t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
+								t.identifier("hasOwnProperty")
+							)
+						]
+					)
+				)
+			])
+		)
 	consoleMethodsReferenced.size &&
 		mainFunction.body.body.unshift(
 			t.variableDeclaration(
@@ -537,7 +566,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				}
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:658:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:687:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -629,39 +658,31 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	})
 	return { file, seclevel }
 	function createGetFunctionPrototypeNode() {
-		for (const globalFunction of globalFunctionsUnder7Characters)
-			if (!program.scope.hasOwnBinding(globalFunction))
-				return t.memberExpression(
-					t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
-					t.identifier("prototype")
-				)
+		const name = globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
 		return t.memberExpression(
-			t.memberExpression(
-				t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
-				t.identifier("constructor")
-			),
-			t.identifier("prototype")
+			name ? t.identifier(name) : t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
+			t.identifier("__proto__")
 		)
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName, seclevel) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:774:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:793:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:776:81"
+				"src/processScript/transform.ts:795:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:777:83"
+				"src/processScript/transform.ts:796:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:781:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:800: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:786:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:805: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.js

@@ -1,4 +1,4 @@
-import { Cache } from "@samual/lib/Cache"
+import { AutoMap } from "@samual/lib/AutoMap"
 import { ensure, assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
@@ -84,8 +84,8 @@ async function push(
 		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())
+	const usersToScriptsToPush = new AutoMap(_user => new Map()),
+		scriptNamesToUsers = new AutoMap(_scriptName => new Set())
 	for (const script of scripts) {
 		const [user, scriptName] = script.split(".")
 		assert(user, "src/push.ts:105:16")
@@ -121,7 +121,7 @@ async function push(
 		for (const user of users)
 			if (!usersToScriptsToPush.get(user).has(scriptName))
 				return new NoScriptsError(`Could not find script ${user}.${scriptName} to push`)
-	const pathsToUsers = new Cache(_path => new Set())
+	const pathsToUsers = new AutoMap(_path => new Set())
 	for (const [user, scriptsToPush] of usersToScriptsToPush)
 		for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
 	const allInfo = []

package/watch.js

@@ -1,10 +1,10 @@
-import { Cache } from "@samual/lib/Cache"
+import { AutoMap } from "@samual/lib/AutoMap"
 import { assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
 import { watch as watch$1 } from "chokidar"
-import { readFile, writeFile } from "fs/promises"
+import { stat, readFile, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
@@ -59,7 +59,8 @@ async function watch(
 	} = {}
 ) {
 	if (!scripts.length) throw Error("scripts option was an empty array")
-	const scriptNamesToUsers = new Cache(_scriptName => new Set()),
+	if (!(await stat(sourceDirectory)).isDirectory()) throw Error("Target folder must be a folder")
+	const scriptNamesToUsers = new AutoMap(_scriptName => new Set()),
 		wildScriptUsers = new Set(),
 		wildUserScripts = new Set()
 	let pushEverything = !1
@@ -91,7 +92,7 @@ async function watch(
 				)
 			)
 				return
-			const scriptNamesToUsersToSkip = new Cache(_scriptName => [])
+			const scriptNamesToUsersToSkip = new AutoMap(_scriptName => [])
 			await Promise.all(
 				(await readDirectoryWithStats(sourceDirectory)).map(async ({ stats, name, path }) => {
 					if (stats.isDirectory())
@@ -136,7 +137,7 @@ async function watch(
 					forceQuineCheats
 				}))
 			} catch (error) {
-				assert(error instanceof Error, "src/watch.ts:141:36")
+				assert(error instanceof Error, "src/watch.ts:146:36")
 				onPush?.({ path, users: [], characterCount: 0, error })
 				return
 			}
@@ -181,7 +182,7 @@ async function watch(
 				forceQuineCheats
 			}))
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:177:35")
+			assert(error instanceof Error, "src/watch.ts:182:35")
 			onPush?.({ path, users: [], characterCount: 0, error })
 			return
 		}
@@ -196,7 +197,7 @@ async function watch(
 		try {
 			await writeFile(typeDeclarationPath, typeDeclaration)
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:210:35")
+			assert(error instanceof Error, "src/watch.ts:215:35")
 			if ("EISDIR" != error.code) throw error
 			typeDeclarationPath = resolve(typeDeclarationPath, "player.d.ts")
 			await writeFile(typeDeclarationPath, typeDeclaration)