hackmud-script-manager 0.19.1-b720a68 → 0.19.1-b80922d

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-b720a68",
+const version = "0.19.1-b80922d",
 	options = new Map(),
 	commands = [],
 	userColours = new Cache(user => {

package/package.json

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

package/processScript/index.d.ts

@@ -3,11 +3,10 @@ export { minify } from "./minify";
 export { postprocess } from "./postprocess";
 export { preprocess } from "./preprocess";
 export { transform } from "./transform";
-export type ProcessOptions = {
+export type ProcessOptions = LaxPartial<{
     /** whether to minify the given code */ minify: boolean;
     /** 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;
-    /** the name of this script (or set to `true` if not yet known) */ scriptName: string | true;
     filePath: string;
     /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
     /** when set to `true` forces use of quine cheats
@@ -17,11 +16,13 @@ export type ProcessOptions = {
       * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
       */
     forceQuineCheats: boolean;
+}> & {
+    scriptName: string | true;
 };
 /** Minifies a given script
   * @param code JavaScript or TypeScript code
   * @param options {@link ProcessOptions details} */
-export declare function processScript(code: string, { minify: shouldMinify, uniqueID, scriptUser, scriptName, filePath, mangleNames, forceQuineCheats }?: LaxPartial<ProcessOptions>): Promise<{
+export declare function processScript(code: string, { minify: shouldMinify, uniqueID, scriptUser, scriptName, filePath, mangleNames, forceQuineCheats }: ProcessOptions): Promise<{
     script: string;
     warnings: {
         message: string;

package/processScript/index.js

@@ -48,13 +48,13 @@ async function processScript(
 			.toString(36)
 			.padStart(11, "0"),
 		scriptUser,
-		scriptName = "UNKNOWN",
+		scriptName,
 		filePath,
 		mangleNames = !1,
 		forceQuineCheats
-	} = {}
+	}
 ) {
-	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:78:36")
+	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:77:36")
 	const sourceCode = code
 	let autocomplete, statedSeclevel
 	const autocompleteMatch = /^function\s*\(.+\/\/(?<autocomplete>.+)/.exec(code)
@@ -115,7 +115,7 @@ async function processScript(
 				}
 			}
 		}
-	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:159:36")
+	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:158:36")
 	const plugins = [
 		[babelPluginProposalDecorators.default, { decoratorsBeforeExport: !0 }],
 		[babelPluginTransformClassProperties.default],
@@ -249,7 +249,7 @@ async function processScript(
 		traverse(file, {
 			MemberExpression({ node: memberExpression }) {
 				if (!memberExpression.computed) {
-					assert("Identifier" == memberExpression.property.type, "src/processScript/index.ts:322:60")
+					assert("Identifier" == memberExpression.property.type, "src/processScript/index.ts:321:60")
 					if ("prototype" == memberExpression.property.name) {
 						memberExpression.computed = !0
 						memberExpression.property = t.stringLiteral("prototype")
@@ -279,7 +279,7 @@ async function processScript(
 							break
 						case "ObjectPattern":
 							for (const property of lValue.properties) {
-								assert("ObjectProperty" == property.type, "src/processScript/index.ts:352:51")
+								assert("ObjectProperty" == property.type, "src/processScript/index.ts:351:51")
 								renameVariables(property.value)
 							}
 							break

package/processScript/minify.d.ts

@@ -1,6 +1,6 @@
 import type { File } from "@babel/types";
 import type { LaxPartial } from "@samual/lib";
-type MinifyOptions = {
+type MinifyOptions = LaxPartial<{
     /** 11 a-z 0-9 characters */ uniqueID: string;
     /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
     /** when set to `true` forces use of quine cheats
@@ -11,8 +11,8 @@ type MinifyOptions = {
       */
     forceQuineCheats: boolean;
     /** the comment inserted after the function signature */ autocomplete: string;
-};
+}>;
 /** @param file babel ast node representing a file containing transformed code
   * @param options {@link MinifyOptions details} */
-export declare function minify(file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: LaxPartial<MinifyOptions>): Promise<string>;
+export declare function minify(file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: MinifyOptions): Promise<string>;
 export {};

package/processScript/preprocess.d.ts

@@ -1,8 +1,9 @@
-export type PreprocessOptions = {
-    /** 11 a-z 0-9 characters */ uniqueID: string;
-};
+import type { LaxPartial } from "@samual/lib";
+export type PreprocessOptions = LaxPartial<{
+    uniqueID: string;
+}>;
 /** @param code source code for preprocessing
   * @param options {@link PreprocessOptions details} */
-export declare function preprocess(code: string, { uniqueID }?: Partial<PreprocessOptions>): Promise<{
+export declare function preprocess(code: string, { uniqueID }?: PreprocessOptions): Promise<{
     code: string;
 }>;

package/processScript/preprocess.js

@@ -8,7 +8,7 @@ import { resolve } from "import-meta-resolve"
 const { default: traverse } = babelTraverse,
 	{ default: generate } = babelGenerator
 async function preprocess(code, { uniqueID = "00000000000" } = {}) {
-	assert(/^\w{11}$/.test(uniqueID), "src/processScript/preprocess.ts:23:36")
+	assert(/^\w{11}$/.test(uniqueID), "src/processScript/preprocess.ts:22:36")
 	const sourceCode = code
 	let lengthBefore, file, program
 	do {
@@ -47,7 +47,7 @@ async function preprocess(code, { uniqueID = "00000000000" } = {}) {
 			})
 			break
 		} catch (error_) {
-			assert(error_ instanceof SyntaxError, "src/processScript/preprocess.ts:67:42")
+			assert(error_ instanceof SyntaxError, "src/processScript/preprocess.ts:66:42")
 			error = error_
 		}
 		if ("BABEL_PARSER_SYNTAX_ERROR" != error.code || "PrivateInExpectedIn" != error.reasonCode) {

package/processScript/transform.d.ts

@@ -1,10 +1,11 @@
 import type { File } from "@babel/types";
 import type { LaxPartial } from "@samual/lib";
-export type TransformOptions = {
+export type TransformOptions = LaxPartial<{
     /** 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;
-    /** the name of this script (or set to `true` if not yet known) */ scriptName: string | true;
     seclevel: number;
+}> & {
+    scriptName: string | true;
 };
 /** transform a given babel `File` to be hackmud compatible
   *
@@ -12,7 +13,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 }?: LaxPartial<TransformOptions>): {
+export declare function transform(file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }: TransformOptions): {
     file: File;
     seclevel: number;
 };

package/processScript/transform.js

@@ -21,11 +21,7 @@ const { default: traverse } = babelTraverse,
 		"Symbol",
 		"BigInt"
 	]
-function transform(
-	file,
-	sourceCode,
-	{ uniqueID = "00000000000", scriptUser, scriptName = "UNKNOWN", seclevel = 4 } = {}
-) {
+function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scriptName, seclevel = 4 }) {
 	const topFunctionName = `_${uniqueID}_SCRIPT_`,
 		exports = new Map(),
 		liveExports = new Map()
@@ -69,30 +65,30 @@ function transform(
 			const referencePath = FunctionReferencePaths[0]
 			assert(
 				"MemberExpression" == referencePath.parent.type,
-				"src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:98:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"Identifier" == referencePath.parent.property.type,
-				"src/processScript/transform.ts:104:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:103:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"prototype" == referencePath.parent.property.name,
-				"src/processScript/transform.ts:109:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:108: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:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:116:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"src/processScript/transform.ts:122:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:121:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"src/processScript/transform.ts:127:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:126:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				functionDotPrototypeIsReferencedMultipleTimes = !0
 				referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
@@ -128,12 +124,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:181:69")
-			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:182:72")
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:180:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:181:72")
 			const databaseOpMethodName = referencePath.parentPath.node.property.name
 			assert(
 				validDBMethods.includes(databaseOpMethodName),
-				`src/processScript/transform.ts:188:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+				`src/processScript/transform.ts:187: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}$`))
@@ -166,7 +162,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:235:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:234:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -176,7 +172,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:250:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:249:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -184,13 +180,13 @@ function transform(
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:264:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:263: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:270:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:269:51 ${specifier.type} is currently unsupported`
 			)
 			const exportedName =
 				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
@@ -313,11 +309,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:404:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:403:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:408:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:407:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -332,9 +328,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:427:23")
+						assert(binding, "src/processScript/transform.ts:426:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:430:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:429:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -378,16 +374,16 @@ function transform(
 				} else globalBlockVariables.add(declarator.id.name)
 			} else if ("ClassDeclaration" == globalBlockStatement.type) {
 				program.scope.crawl()
-				assert(globalBlockStatement.id, "src/processScript/transform.ts:481:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:480: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:493:22")
+					assert(binding, "src/processScript/transform.ts:492:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:496:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:495:55")
 						referencePath.replaceWith(
 							t.memberExpression(
 								t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -554,7 +550,7 @@ function transform(
 				}
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:663:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:662:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -660,23 +656,23 @@ function transform(
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:777:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:776:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:779:81"
+				"src/processScript/transform.ts:778:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:780:83"
+				"src/processScript/transform.ts:779:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:784:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:783: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:789:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:788: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

@@ -1,6 +1,6 @@
 import type { LaxPartial } from "@samual/lib";
 import type { Info } from ".";
-export type PushOptions = {
+export type PushOptions = LaxPartial<{
     /** whether to do the minify step (defaults to `true`) */ minify: boolean;
     /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
     /** array of scripts in the format `foo.bar`
@@ -17,7 +17,7 @@ export type PushOptions = {
       * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
       */
     forceQuineCheats: boolean;
-};
+}>;
 /** Push scripts from a source directory to the hackmud directory.
   *
   * Pushes files directly in the source folder to all users
@@ -25,4 +25,4 @@ export type PushOptions = {
   * @param hackmudDirectory 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(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: LaxPartial<PushOptions>): Promise<Info[]>;
+export declare function push(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;

package/watch.d.ts

@@ -1,14 +1,14 @@
 import type { LaxPartial } from "@samual/lib";
 import type { PushOptions } from "./push";
-export type WatchOptions = PushOptions & {
+export type WatchOptions = PushOptions & LaxPartial<{
     /** if provided, will write typescript type declarations for all the scripts on every change detected
       *
       * writing the type declarations enables interscript type checking and autocompletetes for the args */
     typeDeclarationPath: string;
     onReady: () => void;
-};
+}>;
 /** Watches target file or folder for updates and builds and pushes updated file.
   * @param sourceDirectory path to folder containing source files
   * @param hackmudDirectory path to hackmud directory
   * @param options {@link WatchOptions details} and {@link PushOptions more details} */
-export declare function watch(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, typeDeclarationPath: typeDeclarationPath_, onReady, forceQuineCheats }?: LaxPartial<WatchOptions>): Promise<void>;
+export declare function watch(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, typeDeclarationPath: typeDeclarationPath_, onReady, forceQuineCheats }?: WatchOptions): Promise<void>;