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

package/src/pull.ts

@@ -1,16 +0,0 @@
-import { copyFilePersistent } from "@samual/lib"
-import { resolve as resolvePath } from "path"
-
-/**
- * Copies script from hackmud to local source folder.
- *
- * @param sourceFolderPath path to folder containing source files
- * @param hackmudPath path to hackmud directory
- * @param script script to pull in `user.name` format
- */
-export async function pull(sourceFolderPath: string, hackmudPath: string, script: string) {
-	const [ user, name ] = script.split(".")
-	await copyFilePersistent(resolvePath(hackmudPath, user, "scripts", `${name}.js`), resolvePath(sourceFolderPath, user, `${name}.js`))
-}
-
-export default pull

package/src/push.ts

@@ -1,314 +0,0 @@
-import { countHackmudCharacters, DynamicMap, forEachParallel, writeFilePersistent } from "@samual/lib"
-import fs from "fs"
-import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
-import type { Info } from "."
-import { supportedExtensions } from "./constants.json"
-import processScript from "./processScript"
-
-const { readFile, readdir: readDirectory } = fs.promises
-
-interface PushOptions {
-	/**
-	 * array of scripts in the format `foo.bar`
-	 *
-	 * also accepts wild card e.g. `*.bar` or `foo.*`
-	 *
-	 * pushes everything by default
-	 */
-	scripts: string | string[]
-
-	/** callback when a script is pushed */
-	onPush: (info: Info) => void
-
-	/** whether to do the minify step (defaults to `true`) */
-	minify: boolean
-
-	/** whether to mangle function and class names (defaults to `false`) */
-	mangleNames: boolean
-}
-
-/**
- * Push scripts from a source directory to the hackmud directory.
- *
- * Files directly in the source folder are pushed to all users
- * @param sourceDirectory directory containing source code
- * @param hackmudDirectory directory created by hackmud containing user data including scripts
- * @param options {@link PushOptions details}
- * @returns array of info on pushed scripts
- */
-export async function push(
-	sourceDirectory: string,
-	hackmudDirectory: string,
-	{
-		scripts = "*.*",
-		onPush = (info: Info) => {},
-		minify = true,
-		mangleNames = false
-	}: Partial<PushOptions> = {}
-) {
-	if (typeof scripts == "string")
-		scripts = [ scripts ]
-
-	const scriptNamesByUser = new DynamicMap((user: string) => new Set<string>())
-	const wildScriptUsers = new Set<string>()
-	const wildUserScripts = new Set<string>()
-
-	let pushEverything = false
-
-	for (const fullScriptName of scripts) {
-		const [ user, scriptName ] = fullScriptName.split(".")
-
-		if (!user || user == "*") {
-			if (!scriptName || scriptName == "*")
-				pushEverything = true
-			else
-				wildUserScripts.add(scriptName)
-		} else if (!scriptName || scriptName == "*")
-			wildScriptUsers.add(user)
-		else
-			scriptNamesByUser.get(user).add(scriptName)
-	}
-
-	const usersByGlobalScriptsToPush = new DynamicMap((user: string) => new Set<string>())
-	const allInfo: Info[] = []
-	const scriptNamesAlreadyPushedByUser = new DynamicMap((user: string) => new Set<string>())
-
-	let sourceDirectoryDirents
-
-	// *.bar
-	if (wildUserScripts.size || pushEverything) {
-		const hackmudDirectoryDirents = await readDirectory(resolvePath(hackmudDirectory), { withFileTypes: true })
-
-		const allUsers = new Set([
-			...(sourceDirectoryDirents = await readDirectory(resolvePath(sourceDirectory), { withFileTypes: true }))
-				.filter(dirent => dirent.isDirectory())
-				.map(dirent => dirent.name),
-			...hackmudDirectoryDirents
-				.filter(dirent => dirent.isDirectory())
-				.map(dirent => dirent.name),
-			...hackmudDirectoryDirents
-				.filter(dirent => dirent.isFile() && getFileExtension(dirent.name) == ".key")
-				.map(dirent => dirent.name.slice(0, -4)),
-			...scriptNamesByUser.keys(),
-			...wildScriptUsers
-		])
-
-		if (pushEverything) {
-			for (const user of allUsers)
-				wildScriptUsers.add(user)
-		} else {
-			for (const user of allUsers) {
-				const scriptNames = scriptNamesByUser.get(user)
-
-				for (const scriptName of wildUserScripts)
-					scriptNames.add(scriptName)
-			}
-		}
-	}
-
-	// foo.*
-	await forEachParallel(wildScriptUsers, async user => {
-		await readDirectory(resolvePath(sourceDirectory, user), { withFileTypes: true }).then(async dirents => {
-			await forEachParallel(dirents, async dirent => {
-				const extension = getFileExtension(dirent.name)
-
-				if (dirent.isFile() && supportedExtensions.includes(extension)) {
-					const scriptName = getBaseName(dirent.name, extension)
-					const filePath = resolvePath(sourceDirectory, user, dirent.name)
-
-					const { srcLength, script: minifiedCode } = await processScript(
-						await readFile(filePath, { encoding: "utf-8" }),
-						{
-							minify,
-							scriptUser: user,
-							scriptName,
-							filePath,
-							mangleNames
-						}
-					)
-
-					const info: Info = {
-						file: `${user}/${dirent.name}`,
-						users: [ user ],
-						minLength: countHackmudCharacters(minifiedCode),
-						error: null,
-						srcLength
-					}
-
-					scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
-					allInfo.push(info)
-
-					await writeFilePersistent(resolvePath(hackmudDirectory, user, `scripts/${scriptName}.js`), minifiedCode)
-
-					onPush(info)
-				}
-			})
-		}, (error: NodeJS.ErrnoException) => {
-			if (error.code != "ENOENT")
-				throw error
-		})
-	})
-
-	// foo.bar
-	await forEachParallel(scriptNamesByUser, async ([ user, scripts ]) => {
-		if (wildScriptUsers.has(user))
-			return
-
-		await forEachParallel(scripts, async scriptName => {
-			let code
-			let fileName
-
-			let filePath!: string
-
-			for (const extension of supportedExtensions) {
-				try {
-					fileName = `${scriptName}${extension}`
-					code = await readFile(filePath = resolvePath(sourceDirectory, user, fileName), { encoding: "utf-8" })
-					break
-				} catch {}
-			}
-
-			if (code) {
-				const { srcLength, script: minifiedCode } = await processScript(
-					code,
-					{
-						minify,
-						scriptUser: user,
-						scriptName,
-						filePath,
-						mangleNames
-					}
-				)
-
-				const info: Info = {
-					file: `${user}/${fileName}`,
-					users: [ user ],
-					minLength: countHackmudCharacters(minifiedCode),
-					error: null,
-					srcLength
-				}
-
-				allInfo.push(info)
-
-				await writeFilePersistent(resolvePath(hackmudDirectory, user, "scripts", `${scriptName}.js`), minifiedCode)
-
-				onPush(info)
-			} else
-				usersByGlobalScriptsToPush.get(scriptName).add(user)
-		})
-	})
-
-	// foo.* (global)
-	if (wildScriptUsers.size) {
-		await forEachParallel(sourceDirectoryDirents || await readDirectory(resolvePath(sourceDirectory), { withFileTypes: true }), async dirent => {
-			const extension = getFileExtension(dirent.name)
-
-			if (!dirent.isFile() || !supportedExtensions.includes(extension))
-				return
-
-			const scriptName = getBaseName(dirent.name, extension)
-			const usersToPushTo = [ ...wildScriptUsers, ...usersByGlobalScriptsToPush.get(scriptName) ].filter(user => !scriptNamesAlreadyPushedByUser.get(user).has(scriptName))
-
-			if (!usersToPushTo.length)
-				return
-
-			const uniqueID = Math.floor(Math.random() * (2 ** 52)).toString(36).padStart(11, "0")
-			const filePath = resolvePath(sourceDirectory, dirent.name)
-
-			const { srcLength, script: minifiedCode } = await processScript(
-				await readFile(filePath, { encoding: "utf-8" }),
-				{
-					minify,
-					scriptUser: true,
-					scriptName,
-					uniqueID,
-					filePath,
-					mangleNames
-				}
-			)
-
-			const info: Info = {
-				file: dirent.name,
-				users: usersToPushTo,
-				minLength: countHackmudCharacters(minifiedCode),
-				error: null,
-				srcLength
-			}
-
-			await forEachParallel(usersToPushTo, user =>
-				writeFilePersistent(
-					resolvePath(
-						hackmudDirectory,
-						user,
-						`scripts/${scriptName}.js`
-					),
-					minifiedCode
-						.replace(new RegExp(`$${uniqueID}$SCRIPT_USER`, "g"), user)
-						.replace(new RegExp(`$${uniqueID}$FULL_SCRIPT_NAME`, "g"), `${user}.${scriptName}`)
-				)
-			)
-
-			allInfo.push(info)
-			onPush(info)
-		})
-	} else {
-		// foo.bar (global)
-		await forEachParallel(usersByGlobalScriptsToPush, async ([ scriptName, users ]) => {
-			let code
-			let fileName!: string
-			let filePath!: string
-
-			for (const extension of supportedExtensions) {
-				try {
-					fileName = `${scriptName}${extension}`
-					code = await readFile(filePath = resolvePath(sourceDirectory, fileName), { encoding: "utf-8" })
-					break
-				} catch {}
-			}
-
-			if (code) {
-				const uniqueID = Math.floor(Math.random() * (2 ** 52)).toString(36).padStart(11, "0")
-
-				const { srcLength, script: minifiedCode } = await processScript(
-					code,
-					{
-						minify,
-						scriptUser: true,
-						scriptName,
-						uniqueID,
-						filePath,
-						mangleNames
-					}
-				)
-
-				const info: Info = {
-					file: fileName,
-					users: [ ...users ],
-					minLength: countHackmudCharacters(minifiedCode),
-					error: null,
-					srcLength
-				}
-
-				await forEachParallel(users, user =>
-					writeFilePersistent(
-						resolvePath(
-							hackmudDirectory,
-							user,
-							`scripts/${scriptName}.js`
-						),
-						minifiedCode
-							.replace(new RegExp(`$${uniqueID}$SCRIPT_USER`, "g"), user)
-							.replace(new RegExp(`$${uniqueID}$FULL_SCRIPT_NAME`, "g"), `${user}.${scriptName}`)
-					)
-				)
-
-				allInfo.push(info)
-				onPush(info)
-			}
-		})
-	}
-
-	return allInfo
-}
-
-export default push

package/src/syncMacros.ts

@@ -1,52 +0,0 @@
-import fs from "fs"
-import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
-
-const { readFile, readdir: readDirectory, stat: getFileStatus, writeFile } = fs.promises
-
-export async function syncMacros(hackmudPath: string) {
-	const files = await readDirectory(hackmudPath, { withFileTypes: true })
-	const macros = new Map<string, { macro: string, date: Date }>()
-	const users: string[] = []
-
-	for (const file of files) {
-		if (!file.isFile())
-			continue
-
-		switch (getFileExtension(file.name)) {
-			case ".macros": {
-				const lines = (await readFile(resolvePath(hackmudPath, file.name), { encoding: "utf-8" })).split("\n")
-				const date = (await getFileStatus(resolvePath(hackmudPath, file.name))).mtime
-
-				for (let i = 0; i < lines.length / 2 - 1; i++) {
-					const macroName = lines[i * 2]
-					const curMacro = macros.get(macroName)
-
-					if (!curMacro || date > curMacro.date)
-						macros.set(macroName, { date, macro: lines[i * 2 + 1] })
-				}
-			} break
-
-			case ".key": {
-				users.push(getBaseName(file.name, ".key"))
-			} break
-		}
-	}
-
-	let macroFile = ""
-	let macrosSynced = 0
-
-	for (const [ name, { macro } ] of [ ...macros ].sort(([ a ], [ b ]) => (a as any > b as any) - (a as any < b as any))) {
-		if (macro[0] != macro[0].toLowerCase())
-			continue
-
-		macroFile += `${name}\n${macro}\n`
-		macrosSynced++
-	}
-
-	for (const user of users)
-		writeFile(resolvePath(hackmudPath, user + ".macros"), macroFile)
-
-	return { macrosSynced, usersSynced: users.length }
-}
-
-export default syncMacros

package/src/test.ts

@@ -1,59 +0,0 @@
-import fs from "fs"
-import { extname as getFileExtension, resolve as resolvePath } from "path"
-import { supportedExtensions } from "./constants.json"
-import processScript from "./processScript"
-
-const { readFile, readdir: readDirectory } = fs.promises
-
-export async function test(srcPath: string) {
-	const promises: Promise<any>[] = []
-
-	const errors: {
-		file: string
-		message: string
-		line: number
-	}[] = []
-
-	for (const dirent of await readDirectory(srcPath, { withFileTypes: true })) {
-		if (dirent.isDirectory()) {
-			promises.push(readDirectory(resolvePath(srcPath, dirent.name), { withFileTypes: true }).then(files => {
-				const promises: Promise<any>[] = []
-
-				for (const file of files) {
-					if (!file.isFile() || !supportedExtensions.includes(getFileExtension(file.name)))
-						continue
-
-					promises.push(
-						readFile(resolvePath(srcPath, dirent.name, file.name), { encoding: "utf-8" })
-							.then(processScript)
-							.then(({ warnings }) =>
-								errors.push(...warnings.map(({ message, line }) => ({
-									file: `${dirent.name}/${file.name}`,
-									message, line
-								})))
-							)
-					)
-				}
-
-				return Promise.all(promises)
-			}))
-		} else if (dirent.isFile() && supportedExtensions.includes(getFileExtension(dirent.name))) {
-			promises.push(
-				readFile(resolvePath(srcPath, dirent.name), { encoding: "utf-8" })
-					.then(processScript)
-					.then(({ warnings }) =>
-						errors.push(...warnings.map(({ message, line }) => ({
-							file: dirent.name,
-							message, line
-						})))
-					)
-			)
-		}
-	}
-
-	await Promise.all(promises)
-
-	return errors
-}
-
-export default test

package/src/tsconfig.json

@@ -1,20 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2019", /* ES2019 is oldest properly supported ES version in Node 12 which is the oldest currently supported Node version */
-		"module": "ES2020",
-		"strict": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true,
-		"forceConsistentCasingInFileNames": true,
-		"declaration": true,
-		"outDir": "../dist",
-		"useUnknownInCatchVariables": true,
-		"exactOptionalPropertyTypes": true,
-		"noImplicitOverride": true,
-		"moduleResolution": "Node",
-		"resolveJsonModule": true,
-		"emitDeclarationOnly": true
-	},
-	"exclude": [ "bin" ],
-	"references": [ { "path": ".." } ]
-}

package/src/watch.ts

@@ -1,156 +0,0 @@
-import { countHackmudCharacters, writeFilePersistent } from "@samual/lib"
-import { watch as watchDirectory } from "chokidar"
-import fs from "fs"
-import { basename as getBaseName, extname as getFileExtension, resolve as resolvePath } from "path"
-import type { Info } from "."
-import { supportedExtensions } from "./constants.json"
-import generateTypings from "./generateTypings"
-import processScript from "./processScript"
-
-const { readFile, readdir: readDirectory } = fs.promises
-
-/**
- * Watches target file or folder for updates and builds and pushes updated file.
- *
- * @param srcDir path to folder containing source files
- * @param hackmudDir path to hackmud directory
- * @param users users to push to (pushes to all if empty)
- * @param scripts scripts to push from (pushes from all if empty)
- * @param onPush function that's called after each script has been built and written
- */
-export function watch(srcDir: string, hackmudDir: string, users: string[], scripts: string[], onPush?: (info: Info) => void, { genTypes }: { genTypes?: string | undefined } = {}) {
-	const watcher = watchDirectory("", { depth: 1, cwd: srcDir, awaitWriteFinish: { stabilityThreshold: 100 } }).on("change", async path => {
-		const extension = getFileExtension(path)
-
-		if (supportedExtensions.includes(extension)) {
-			const name = getBaseName(path, extension)
-			const fileName = getBaseName(path)
-
-			if (path == fileName) {
-				if (!scripts.length || scripts.includes(name)) {
-					const sourceCode = await readFile(resolvePath(srcDir, path), { encoding: "utf-8" })
-					const skips = new Map<string, string[]>()
-					const promisesSkips: Promise<any>[] = []
-
-					for (const dir of await readDirectory(srcDir, { withFileTypes: true })) {
-						if (!dir.isDirectory())
-							continue
-
-						promisesSkips.push(readDirectory(resolvePath(srcDir, dir.name), { withFileTypes: true }).then(files => {
-							for (const file of files) {
-								if (!file.isFile())
-									continue
-
-								const fileExtension = getFileExtension(file.name)
-
-								if (!supportedExtensions.includes(fileExtension))
-									continue
-
-								const name = getBaseName(file.name, fileExtension)
-								const skip = skips.get(name)
-
-								if (skip)
-									skip.push(dir.name)
-								else
-									skips.set(name, [ dir.name ])
-							}
-						}))
-					}
-
-					await Promise.all(promisesSkips)
-
-					let error = null
-
-					const { script, srcLength } = await processScript(sourceCode).catch(reason => {
-						error = reason
-
-						return {
-							script: "",
-							srcLength: 0
-						}
-					})
-
-					const info: Info = {
-						file: path,
-						users: [],
-						minLength: 0,
-						error,
-						srcLength
-					}
-
-					const promises: Promise<any>[] = []
-
-					if (!error) {
-						if (script) {
-							const skip = skips.get(name) || []
-
-							info.minLength = countHackmudCharacters(script)
-
-							if (!users.length) {
-								users = (await readDirectory(hackmudDir, { withFileTypes: true }))
-									.filter(a => a.isFile() && getFileExtension(a.name) == ".key")
-									.map(a => getBaseName(a.name, ".key"))
-							}
-
-							for (const user of users) {
-								if (skip.includes(user))
-									continue
-
-								info.users.push(user)
-								promises.push(writeFilePersistent(resolvePath(hackmudDir, user, "scripts", `${name}.js`), script))
-							}
-						} else
-							info.error = new Error("processed script was empty")
-					}
-
-					if (onPush) {
-						await Promise.all(promises)
-						onPush(info)
-					}
-				}
-			} else {
-				const user = getBaseName(resolvePath(path, ".."))
-
-				if ((!users.length || users.includes(user)) && (!scripts.length || scripts.includes(name))) {
-					const sourceCode = await readFile(resolvePath(srcDir, path), { encoding: "utf-8" })
-					let error = null
-
-					const { script, srcLength } = await processScript(sourceCode).catch(reason => {
-						error = reason
-
-						return {
-							script: "",
-							srcLength: 0
-						}
-					})
-
-					const info: Info = {
-						file: path,
-						users: [ user ],
-						minLength: 0,
-						error,
-						srcLength
-					}
-
-					if (!error) {
-						if (script) {
-							info.minLength = countHackmudCharacters(script)
-							await writeFilePersistent(resolvePath(hackmudDir, user, "scripts", `${name}.js`), script)
-						} else
-							info.error = new Error("processed script was empty")
-					}
-
-					onPush?.(info)
-				}
-			}
-		}
-	})
-
-	if (genTypes) {
-		generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir)
-		watcher.on("add", () => generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir))
-		watcher.on("unlink", () => generateTypings(srcDir, resolvePath(srcDir, genTypes), hackmudDir))
-	}
-}
-
-export default watch

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-	"compilerOptions": {
-		"rootDir": ".",
-		"outDir": ".",
-		"resolveJsonModule": true,
-		"composite": true,
-		"emitDeclarationOnly": true,
-		"skipLibCheck": true
-	},
-	"files": [ "package.json" ],
-	"exclude": [ "src" ]
-}