hackmud-script-manager 0.19.1-5bceac8 → 0.19.1-6d8d544

package/pull.d.ts

@@ -1,9 +1,5 @@
-/**
- * Copies script from hackmud to local source folder.
- *
- * @param sourceFolderPath path to folder containing source files
- * @param hackmudPath path to hackmud directory
- * @param script to pull in `user.name` format
- */
-export declare const pull: (sourceFolderPath: string, hackmudPath: string, script: string) => Promise<void>;
-export default pull;
+/** Copies script from hackmud to local source folder.
+  * @param sourceFolderPath path to folder containing source files
+  * @param hackmudPath path to hackmud directory
+  * @param script to pull in `user.name` format */
+export declare function pull(sourceFolderPath: string, hackmudPath: string, script: string): Promise<void>;

package/pull.js

@@ -1,6 +1,6 @@
 import { copyFilePersistent } from "@samual/lib/copyFilePersistent"
 import { resolve } from "path"
-const pull = async (sourceFolderPath, hackmudPath, script) => {
+async function pull(sourceFolderPath, hackmudPath, script) {
 	const [user, name] = script.split(".")
 	if (!user || !name) throw Error('`script` argument must be in "user.name" format')
 	await copyFilePersistent(
@@ -8,4 +8,4 @@ const pull = async (sourceFolderPath, hackmudPath, script) => {
 		resolve(sourceFolderPath, user, name + ".js")
 	)
 }
-export { pull as default, pull }
+export { pull }

package/push.d.ts

@@ -1,37 +1,28 @@
 import type { LaxPartial } from "@samual/lib";
 import type { Info } from ".";
-export type PushOptions = {
-    /** 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`
-     *
-     * also accepts wild card (`*`) e.g. `*.bar` or `foo.*`
-     *
-     * pushes everything by default (`*.*`)
-     */
+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`
+      *
+      * also accepts wild card (`*`) e.g. `*.bar` or `foo.*`
+      *
+      * pushes everything by default (`*.*`) */
     scripts: string[];
-    /** callback called on script push */
-    onPush: (info: Info) => void;
-    /**
-     * when set to `true` forces use of quine cheats
-     *
-     * when set to `false` forces quine cheats not to be used
-     *
-     * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
-     */
+    /** callback called on script push */ onPush: (info: Info) => void;
+    /** when set to `true` forces use of quine cheats
+      *
+      * when set to `false` forces quine cheats not to be used
+      *
+      * 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
- * @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 declare const push: (sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: LaxPartial<PushOptions>) => Promise<Info[]>;
-export default push;
+}>;
+/** Push scripts from a source directory to the hackmud directory.
+  *
+  * Pushes files directly in the source folder to all users
+  * @param sourcePath directory containing source code
+  * @param hackmudPath 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(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;

package/push.js

@@ -1,9 +1,10 @@
 import { Cache } from "@samual/lib/Cache"
+import { ensure, assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
+import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
-import { readdir, readFile } from "fs/promises"
-import { resolve, extname, basename } from "path"
-import { supportedExtensions } from "./constants.js"
+import { readFile } from "fs/promises"
+import { basename, resolve } from "path"
 import { processScript } from "./processScript/index.js"
 import "@babel/generator"
 import "@babel/parser"
@@ -28,9 +29,9 @@ import "@rollup/plugin-babel"
 import "@rollup/plugin-commonjs"
 import "@rollup/plugin-json"
 import "@rollup/plugin-node-resolve"
-import "@samual/lib/assert"
 import "prettier"
 import "rollup"
+import "./constants.js"
 import "./processScript/minify.js"
 import "@samual/lib/spliceString"
 import "acorn"
@@ -41,223 +42,97 @@ import "./processScript/preprocess.js"
 import "import-meta-resolve"
 import "./processScript/transform.js"
 import "@samual/lib/clearObject"
-const push = async (
-	sourceDirectory,
-	hackmudDirectory,
+async function push(
+	sourcePath,
+	hackmudPath,
 	{ scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
-) => {
-	const scriptNamesByUser = new Cache(_user => new Set()),
-		wildScriptUsers = new Set(),
-		wildUserScripts = new Set()
-	let pushEverything = !1
-	for (const fullScriptName of scripts) {
-		const [user, scriptName] = fullScriptName.split(".")
-		user && "*" != user ?
-			scriptName && "*" != scriptName ?
-				scriptNamesByUser.get(user).add(scriptName)
-			:	wildScriptUsers.add(user)
-		: scriptName && "*" != scriptName ? wildUserScripts.add(scriptName)
-		: (pushEverything = !0)
+) {
+	const [sourceFolder, hackmudFolder] = await Promise.all([
+			readDirectoryWithStats(sourcePath),
+			readDirectoryWithStats(hackmudPath)
+		]),
+		sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
+		allUsers = new Set([
+			...scripts
+				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:52:65"))
+				.filter(name => "*" != name),
+			...sourceFolderFolders.map(({ name }) => name),
+			...hackmudFolder.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
+			...hackmudFolder
+				.filter(({ stats, name }) => stats.isFile() && name.endsWith(".key"))
+				.map(({ name }) => name.slice(0, -4))
+		]),
+		usersToScriptsToPush = new Cache(_user => new Map()),
+		scriptNamesToUsers = new Cache(_scriptName => new Set())
+	for (const script of scripts) {
+		const [user, scriptName] = script.split(".")
+		assert(user, "src/push.ts:69:16")
+		assert(scriptName, "src/push.ts:70:22")
+		"*" == user ? scriptNamesToUsers.set(scriptName, allUsers) : scriptNamesToUsers.get(scriptName).add(user)
 	}
-	const usersByGlobalScriptsToPush = new Cache(_user => new Set()),
-		allInfo = [],
-		scriptNamesAlreadyPushedByUser = new Cache(_user => new Set())
-	let sourceDirectoryDirents
-	if (wildUserScripts.size || pushEverything) {
-		const hackmudDirectoryDirents = await readdir(resolve(hackmudDirectory), { withFileTypes: !0 }),
-			allUsers = new Set([
-				...(sourceDirectoryDirents = await readdir(resolve(sourceDirectory), { withFileTypes: !0 }))
-					.filter(dirent => dirent.isDirectory())
-					.map(dirent => dirent.name),
-				...hackmudDirectoryDirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name),
-				...hackmudDirectoryDirents
-					.filter(dirent => dirent.isFile() && dirent.name.endsWith(".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)
-			}
+	const sourceFolderFiles = sourceFolder.filter(({ stats }) => stats.isFile()),
+		wildScriptUsers_ = scriptNamesToUsers.get("*")
+	scriptNamesToUsers.delete("*")
+	for (const { name, path } of [
+		...sourceFolderFiles.filter(({ name }) => name.endsWith(".js")),
+		...sourceFolderFiles.filter(({ name }) => name.endsWith(".ts"))
+	]) {
+		const scriptName = name.slice(0, -3)
+		for (const user of [...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)])
+			usersToScriptsToPush.get(user).set(scriptName, path)
 	}
 	await Promise.all(
-		[...wildScriptUsers].map(async user => {
-			await readdir(resolve(sourceDirectory, user), { withFileTypes: !0 }).then(
-				async dirents => {
-					await Promise.all(
-						dirents.map(async dirent => {
-							if (dirent.name.endsWith(".d.ts")) return
-							const extension = extname(dirent.name)
-							if (dirent.isFile() && supportedExtensions.includes(extension)) {
-								const scriptName = basename(dirent.name, extension),
-									filePath = resolve(sourceDirectory, user, dirent.name),
-									{ script: minifiedCode } = await processScript(
-										await readFile(filePath, { encoding: "utf-8" }),
-										{
-											minify,
-											scriptUser: user,
-											scriptName,
-											filePath,
-											mangleNames,
-											forceQuineCheats
-										}
-									),
-									info = {
-										file: `${user}/${dirent.name}`,
-										users: [user],
-										minLength: countHackmudCharacters(minifiedCode),
-										error: void 0
-									}
-								scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
-								allInfo.push(info)
-								await writeFilePersistent(
-									resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-									minifiedCode
-								)
-								onPush(info)
-							}
-						})
-					)
-				},
-				error => {
-					if ("ENOENT" != error.code) throw error
-				}
-			)
+		sourceFolderFolders.map(async ({ name: user, path }) => {
+			const files = (await readDirectoryWithStats(path)).filter(({ stats }) => stats.isFile()),
+				scriptFiles = [
+					...files.filter(({ name }) => name.endsWith(".js")),
+					...files.filter(({ name }) => name.endsWith(".ts"))
+				]
+			for (const { name, path } of scriptFiles) {
+				const scriptName = name.slice(0, -3)
+				;[...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)].includes(user) &&
+					usersToScriptsToPush.get(user).set(scriptName, path)
+			}
 		})
 	)
+	for (const [scriptName, users] of scriptNamesToUsers)
+		for (const user of users)
+			if (!usersToScriptsToPush.get(user).has(scriptName))
+				throw Error(`Could not find script ${user}.${scriptName} to push`)
+	const pathsToUsers = new Cache(_path => new Set())
+	for (const [user, scriptsToPush] of usersToScriptsToPush)
+		for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
+	const allInfo = []
 	await Promise.all(
-		[...scriptNamesByUser].map(async ([user, scripts]) => {
-			wildScriptUsers.has(user) ||
-				(await Promise.all(
-					[...scripts].map(async scriptName => {
-						let code, fileName, filePath
-						for (const extension of supportedExtensions)
-							try {
-								fileName = `${scriptName}${extension}`
-								code = await readFile((filePath = resolve(sourceDirectory, user, fileName)), {
-									encoding: "utf-8"
-								})
-								break
-							} catch {}
-						if (code) {
-							const { script: minifiedCode } = await processScript(code, {
-									minify,
-									scriptUser: user,
-									scriptName,
-									filePath,
-									mangleNames,
-									forceQuineCheats
-								}),
-								info = {
-									file: `${user}/${fileName}`,
-									users: [user],
-									minLength: countHackmudCharacters(minifiedCode),
-									error: void 0
-								}
-							allInfo.push(info)
-							await writeFilePersistent(
-								resolve(hackmudDirectory, user, "scripts", scriptName + ".js"),
-								minifiedCode
-							)
-							onPush(info)
-						} else usersByGlobalScriptsToPush.get(scriptName).add(user)
-					})
-				))
-		})
-	)
-	await (wildScriptUsers.size ?
-		Promise.all(
-			(sourceDirectoryDirents || (await readdir(resolve(sourceDirectory), { withFileTypes: !0 }))).map(
-				async dirent => {
-					if (dirent.name.endsWith(".d.ts")) return
-					const extension = extname(dirent.name)
-					if (!dirent.isFile() || !supportedExtensions.includes(extension)) return
-					const scriptName = basename(dirent.name, extension),
-						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"),
-						filePath = resolve(sourceDirectory, dirent.name),
-						{ script: minifiedCode } = await processScript(
-							await readFile(filePath, { encoding: "utf-8" }),
-							{ minify, scriptUser: !0, scriptName, uniqueID, filePath, mangleNames, forceQuineCheats }
-						),
-						info = {
-							file: dirent.name,
-							users: usersToPushTo,
-							minLength: countHackmudCharacters(minifiedCode),
-							error: void 0
-						}
-					await Promise.all(
-						usersToPushTo.map(user =>
-							writeFilePersistent(
-								resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-								minifiedCode
-									.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
-									.replace(
-										RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
-										`${user}.${scriptName}`
-									)
-							)
-						)
+		[...pathsToUsers].map(async ([path, [...users]]) => {
+			const scriptName = basename(path.slice(0, -3)),
+				uniqueID = Math.floor(Math.random() * 2 ** 52)
+					.toString(36)
+					.padStart(11, "0"),
+				{ script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf8" }), {
+					minify,
+					scriptUser: !0,
+					scriptName,
+					uniqueID,
+					filePath: path,
+					mangleNames,
+					forceQuineCheats
+				}),
+				info = { path, users, characterCount: countHackmudCharacters(minifiedCode), error: void 0 }
+			await Promise.all(
+				users.map(user =>
+					writeFilePersistent(
+						resolve(hackmudPath, user, `scripts/${scriptName}.js`),
+						minifiedCode
+							.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
+							.replace(RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"), `${user}.${scriptName}`)
 					)
-					allInfo.push(info)
-					onPush(info)
-				}
+				)
 			)
-		)
-	:	Promise.all(
-			[...usersByGlobalScriptsToPush].map(async ([scriptName, users]) => {
-				let code, fileName, filePath
-				for (const extension of supportedExtensions)
-					try {
-						fileName = `${scriptName}${extension}`
-						code = await readFile((filePath = resolve(sourceDirectory, fileName)), { encoding: "utf-8" })
-						break
-					} catch {}
-				if (code) {
-					const uniqueID = Math.floor(Math.random() * 2 ** 52)
-							.toString(36)
-							.padStart(11, "0"),
-						{ script: minifiedCode } = await processScript(code, {
-							minify,
-							scriptUser: !0,
-							scriptName,
-							uniqueID,
-							filePath,
-							mangleNames,
-							forceQuineCheats
-						}),
-						info = {
-							file: fileName,
-							users: [...users],
-							minLength: countHackmudCharacters(minifiedCode),
-							error: void 0
-						}
-					await Promise.all(
-						[...users].map(user =>
-							writeFilePersistent(
-								resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
-								minifiedCode
-									.replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
-									.replace(
-										RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
-										`${user}.${scriptName}`
-									)
-							)
-						)
-					)
-					allInfo.push(info)
-					onPush(info)
-				}
-			})
-		))
+			allInfo.push(info)
+			onPush(info)
+		})
+	)
 	return allInfo
 }
-export { push as default, push }
+export { push }

package/syncMacros.d.ts

@@ -1,5 +1,4 @@
-export declare const syncMacros: (hackmudPath: string) => Promise<{
+export declare function syncMacros(hackmudPath: string): Promise<{
     macrosSynced: number;
     usersSynced: number;
 }>;
-export default syncMacros;

package/syncMacros.js

@@ -1,17 +1,18 @@
-import { readdir, readFile, stat, writeFile } from "fs/promises"
+import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
+import { readFile, stat, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
-const syncMacros = async hackmudPath => {
-	const files = await readdir(hackmudPath, { withFileTypes: !0 }),
+async function syncMacros(hackmudPath) {
+	const files = await readDirectoryWithStats(hackmudPath),
 		macros = new Map(),
 		users = []
 	await Promise.all(
 		files.map(async file => {
-			if (file.isFile())
+			if (file.stats.isFile())
 				switch (extname(file.name)) {
 					case ".macros":
 						{
 							const [lines, date] = await Promise.all([
-								readFile(resolve(hackmudPath, file.name), { encoding: "utf-8" }).then(file =>
+								readFile(resolve(hackmudPath, file.name), { encoding: "utf8" }).then(file =>
 									file.split("\n")
 								),
 								stat(resolve(hackmudPath, file.name)).then(({ mtime }) => mtime)
@@ -39,4 +40,4 @@ const syncMacros = async hackmudPath => {
 	for (const user of users) writeFile(resolve(hackmudPath, user + ".macros"), macroFile)
 	return { macrosSynced, usersSynced: users.length }
 }
-export { syncMacros as default, syncMacros }
+export { syncMacros }