hackmud-script-manager 0.13.0-c461329 → 0.13.0-f373e9c

package/src/generateTypings.ts

@@ -1,116 +0,0 @@
-import fs from "fs"
-import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
-
-const { readdir: readDirectory, writeFile } = fs.promises
-
-export async function generateTypings(srcDir: string, target: string, hackmudPath?: string) {
-	const users = new Set<string>()
-
-	if (hackmudPath) {
-		for (const dirent of await readDirectory(hackmudPath, { withFileTypes: true })) {
-			if (dirent.isFile() && getFileExtension(dirent.name) == ".key")
-				users.add(getBaseName(dirent.name, ".key"))
-		}
-	}
-
-	const wildScripts: string[] = []
-	const wildAnyScripts: string[] = []
-	const allScripts: Record<string, string[]> = {}
-	const allAnyScripts: Record<string, string[]> = {}
-
-	for (const dirent of await readDirectory(srcDir, { withFileTypes: true })) {
-		if (dirent.isFile()) {
-			if (getFileExtension(dirent.name) == ".ts")
-				wildScripts.push(getBaseName(dirent.name, ".ts"))
-			else if (getFileExtension(dirent.name) == ".js")
-				wildAnyScripts.push(getBaseName(dirent.name, ".js"))
-		} else if (dirent.isDirectory()) {
-			const scripts: string[] = allScripts[dirent.name] = []
-			const anyScripts: string[] = allAnyScripts[dirent.name] = []
-
-			users.add(dirent.name)
-
-			for (const file of await readDirectory(resolvePath(srcDir, dirent.name), { withFileTypes: true })) {
-				if (file.isFile()) {
-					if (getFileExtension(file.name) == ".ts")
-						scripts.push(getBaseName(file.name, ".ts"))
-					else if (getFileExtension(file.name) == ".js")
-						anyScripts.push(getBaseName(file.name, ".js"))
-				}
-			}
-		}
-	}
-
-	let o = ""
-
-	for (const script of wildScripts)
-		o += `import { script as $${script}$ } from "./src/${script}"\n`
-
-	o += "\n"
-
-	for (const user in allScripts) {
-		const scripts = allScripts[user]
-
-		for (const script of scripts)
-			o += `import { script as $${user}$${script}$ } from "./src/${user}/${script}"\n`
-	}
-
-	// TODO detect security level and generate apropriate code
-
-	// TODO accurate function signatures
-	// currently I lose the generic-ness of my functions when I wrap them
-	// just regexing isn't enough and it looks like I'm going to need to parse the files in TypeScript to extract the signature
-
-	o += `
-type ArrayRemoveFirst<A> = A extends [ infer FirstItem, ...infer Rest ] ? Rest : never
-
-type Subscript<T extends (...args: any) => any> =
-	(...args: ArrayRemoveFirst<Parameters<T>>) => ReturnType<T> | ScriptFailure
-
-type WildFullsec = Record<string, () => ScriptFailure> & {
-`
-
-	for (const script of wildScripts)
-		o += `\t${script}: Subscript<typeof $${script}$>\n`
-
-	for (const script of wildAnyScripts)
-		o += `\t${script}: (...args: any) => any\n`
-
-	o += "}\n\ndeclare global {\n\tinterface PlayerFullsec {"
-
-	let lastWasMultiLine = true
-
-	for (const user of users) {
-		const scripts = allScripts[user]
-		const anyScripts = allAnyScripts[user]
-
-		if ((scripts && scripts.length) || (anyScripts && anyScripts.length)) {
-			lastWasMultiLine = true
-
-			o += `\n\t\t${user}: WildFullsec & {\n`
-
-			for (const script of scripts)
-				o += `\t\t\t${script}: Subscript<typeof $${user}$${script}$>\n`
-
-			for (const script of anyScripts)
-				o += `\t\t\t${script}: (...args: any) => any\n`
-
-			o += "\t\t}"
-		} else {
-			if (lastWasMultiLine) {
-				o += "\n"
-				lastWasMultiLine = false
-			}
-
-			o += `\t\t${user}: WildFullsec`
-		}
-
-		o += "\n"
-	}
-
-	o += "\t}\n}\n"
-
-	await writeFile(target, o)
-}
-
-export default generateTypings

package/src/index.ts

@@ -1,19 +0,0 @@
-export { supportedExtensions } from "./constants.json"
-export { generateTypings } from "./generateTypings"
-export { processScript } from "./processScript"
-export { pull } from "./pull"
-export { push } from "./push"
-export { syncMacros } from "./syncMacros"
-export { test } from "./test"
-export { watch } from "./watch"
-
-// TODO `clean()` function that delete all scripts in hackmud directory #70
-// TODO optional argument (defaults to false) for `clean()` that makes it only remove scripts without a source file #70
-
-export interface Info {
-	file: string
-	users: string[]
-	srcLength: number
-	minLength: number
-	error: Error | null
-}

package/src/modules.d.ts

@@ -1,5 +0,0 @@
-declare module "@babel/plugin-*" {
-	export default {
-		default: (...args: any[]) => any
-	}
-}

package/src/processScript/index.ts

@@ -1,198 +0,0 @@
-import babelGenerator from "@babel/generator"
-import { parse } from "@babel/parser"
-import babelPluginProposalClassProperties from "@babel/plugin-proposal-class-properties"
-import babelPluginProposalClassStaticBlock from "@babel/plugin-proposal-class-static-block"
-import babelPluginProposalDecorators from "@babel/plugin-proposal-decorators"
-import babelPluginProposalDoExpressions from "@babel/plugin-proposal-do-expressions"
-import babelPluginProposalFunctionBind from "@babel/plugin-proposal-function-bind"
-import babelPluginProposalFunctionSent from "@babel/plugin-proposal-function-sent"
-import babelPluginProposalJSONStrings from "@babel/plugin-proposal-json-strings"
-import babelPluginProposalLogicalAssignmentOperators from "@babel/plugin-proposal-logical-assignment-operators"
-import babelPluginProposalNullishCoalescingOperator from "@babel/plugin-proposal-nullish-coalescing-operator"
-import babelPluginProposalNumericSeparator from "@babel/plugin-proposal-numeric-separator"
-import babelPluginProposalObjectRestSpread from "@babel/plugin-proposal-object-rest-spread"
-import babelPluginProposalOptionalCatchBinding from "@babel/plugin-proposal-optional-catch-binding"
-import babelPluginProposalOptionalChaining from "@babel/plugin-proposal-optional-chaining"
-import babelPluginProposalPartialApplication from "@babel/plugin-proposal-partial-application"
-import babelPluginProposalPipelineOperator from "@babel/plugin-proposal-pipeline-operator"
-import babelPluginProposalPrivatePropertyInObject from "@babel/plugin-proposal-private-property-in-object"
-import babelPluginProposalRecordAndTuple from "@babel/plugin-proposal-record-and-tuple"
-import babelPluginProposalThrowExpressions from "@babel/plugin-proposal-throw-expressions"
-import babelPluginTransformExponentiationOperator from "@babel/plugin-transform-exponentiation-operator"
-import babelPluginTransformTypescript from "@babel/plugin-transform-typescript"
-import rollupPluginBabel_ from "@rollup/plugin-babel"
-import rollupPluginCommonJS from "@rollup/plugin-commonjs"
-import rollupPluginJSON from "@rollup/plugin-json"
-import rollupPluginNodeResolve from "@rollup/plugin-node-resolve"
-import { assert, countHackmudCharacters } from "@samual/lib"
-import { resolve as resolvePath } from "path"
-import { performance } from "perf_hooks"
-import prettier from "prettier"
-import { rollup } from "rollup"
-import { supportedExtensions as extensions } from "../constants.json"
-import minify from "./minify"
-import postprocess from "./postprocess"
-import preprocess from "./preprocess"
-import transform from "./transform"
-
-const { default: rollupPluginBabel } = rollupPluginBabel_ as any as typeof import("@rollup/plugin-babel")
-const { format } = prettier
-const { default: generate } = babelGenerator as any as typeof import("@babel/generator")
-
-export { minify } from "./minify"
-export { postprocess } from "./postprocess"
-export { preprocess } from "./preprocess"
-export { transform as compile } from "./transform"
-
-export type ProcessOptions = {
-	/** whether to minify the given code */
-	minify: boolean
-
-	/** 11 a-z 0-9 characters */
-	uniqueID: string
-
-	/** the user the script will be uploaded to (or set to `true` if it is not yet known) */
-	scriptUser: string | true
-
-	/** the name of this script (or set to `true` if it is not yet known) */
-	scriptName: string | true
-
-	filePath: string
-
-	/** whether to mangle function and class names (defaults to `false`) */
-	mangleNames: boolean
-}
-
-/**
- * Minifies a given script
- *
- * @param code JavaScript or TypeScript code
- * @param options {@link ProcessOptions details}
- */
-export async function processScript(
-	code: string,
-	{
-		minify: shouldMinify = true,
-		uniqueID = Math.floor(Math.random() * (2 ** 52)).toString(36).padStart(11, "0"),
-		scriptUser = "UNKNOWN",
-		scriptName = "UNKNOWN",
-		filePath,
-		mangleNames = false
-	}: Partial<ProcessOptions> = {}
-): Promise<{
-	srcLength: number
-	script: string
-	warnings: { message: string, line: number }[]
-	timeTook: number
-}> {
-	assert(uniqueID.match(/^\w{11}$/))
-
-	if (filePath)
-		filePath = resolvePath(filePath)
-	else
-		filePath = "script"
-
-	const time = performance.now()
-	const sourceCode = code
-	let autocomplete
-	let seclevel
-	let semicolons
-
-	({ autocomplete, code, seclevel, semicolons } = preprocess(code, { uniqueID }))
-	assert(uniqueID.match(/^\w{11}$/))
-
-	const filePathResolved = filePath
-		? resolvePath(filePath)
-		: "script"
-
-	const bundle = await rollup({
-		plugins: [
-			{
-				name: "emit script",
-				buildStart() {
-					this.emitFile({
-						type: "chunk",
-						id: filePathResolved
-					})
-				},
-				load(id) {
-					if (id == filePathResolved)
-						return code
-
-					return null
-				},
-				transform(code) {
-					return preprocess(code, { uniqueID }).code
-				}
-			},
-			rollupPluginBabel({
-				babelHelpers: "bundled",
-				plugins: [
-					[ babelPluginTransformTypescript.default ],
-					[ babelPluginProposalDecorators.default, { decoratorsBeforeExport: true } ],
-					[ babelPluginProposalDoExpressions.default ],
-					[ babelPluginProposalFunctionBind.default ],
-					[ babelPluginProposalFunctionSent.default ],
-					[ babelPluginProposalPartialApplication.default ],
-					[ babelPluginProposalPipelineOperator.default, { proposal: "hack", topicToken: "%" } ],
-					[ babelPluginProposalThrowExpressions.default ],
-					[ babelPluginProposalRecordAndTuple.default, { syntaxType: "hash", importPolyfill: true } ],
-					[ babelPluginProposalClassProperties.default ],
-					[ babelPluginProposalClassStaticBlock.default ],
-					[ babelPluginProposalPrivatePropertyInObject.default ],
-					[ babelPluginProposalLogicalAssignmentOperators.default ],
-					[ babelPluginProposalNumericSeparator.default ],
-					[ babelPluginProposalNullishCoalescingOperator.default ],
-					[ babelPluginProposalOptionalChaining.default ],
-					[ babelPluginProposalOptionalCatchBinding.default ],
-					[ babelPluginProposalJSONStrings.default ],
-					[ babelPluginProposalObjectRestSpread.default ],
-					[ babelPluginTransformExponentiationOperator.default ]
-				],
-				configFile: false,
-				extensions
-			}),
-			rollupPluginCommonJS(),
-			rollupPluginNodeResolve({ extensions }),
-			rollupPluginJSON()
-		]
-	})
-
-	code = (await bundle.generate({})).output[0].code
-
-	const file = parse(code, { sourceType: "module" })
-
-	code = generate(await transform(file, sourceCode, { uniqueID, scriptUser, scriptName, seclevel })!).code
-
-	// TODO fix incorrect source length again
-
-	// the typescript inserts semicolons where they weren't already so we take
-	// all semicolons out of the count and add the number of semicolons in the
-	// source to make things fair
-	let srcLength = countHackmudCharacters(code.replace(/^function\s*\w+\(/, "function("))
-		- (code.match(/;/g)?.length || 0)
-		+ semicolons
-		// + (code.match(/SC\$[a-zA-Z_][a-zA-Z0-9_]*\$[a-zA-Z_][a-zA-Z0-9_]*\(/g)?.length ?? 0)
-		// + (code.match(/DB\$/g)?.length ?? 0)
-
-	if (shouldMinify)
-		code = await minify(code, autocomplete, { uniqueID, mangleNames })
-	else {
-		code = format(code, {
-			parser: "babel",
-			arrowParens: "avoid",
-			semi: false
-		})
-	}
-
-	code = postprocess(code, seclevel, uniqueID)
-
-	return {
-		srcLength,
-		script: code,
-		warnings: [],
-		timeTook: performance.now() - time
-	}
-}
-
-export default processScript