hackmud-script-manager 0.19.1-cb8d65f → 0.19.1-d57be2a

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -21,11 +21,7 @@ const { default: traverse } = babelTraverse,
21
21
  "Symbol",
22
22
  "BigInt"
23
23
  ]
24
- function transform(
25
- file,
26
- sourceCode,
27
- { uniqueID = "00000000000", scriptUser = "UNKNOWN", scriptName = "UNKNOWN", seclevel = 4 } = {}
28
- ) {
24
+ function transform(file, sourceCode, { uniqueID = "00000000000", scriptUser, scriptName, seclevel = 4 }) {
29
25
  const topFunctionName = `_${uniqueID}_SCRIPT_`,
30
26
  exports = new Map(),
31
27
  liveExports = new Map()
@@ -42,21 +38,31 @@ function transform(
42
38
  if (program.scope.hasGlobal("_BUILD_DATE"))
43
39
  for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
44
40
  referencePath.replaceWith(t.numericLiteral(Date.now()))
41
+ let uniqueIdScriptUserNeeded = !1
45
42
  if (program.scope.hasGlobal("_SCRIPT_USER"))
46
43
  for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
47
- referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
44
+ if (null == scriptUser) {
45
+ uniqueIdScriptUserNeeded = !0
46
+ referencePath.replaceWith(t.identifier(`_${uniqueID}_SCRIPT_USER_`))
47
+ } else
48
+ referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
48
49
  if (program.scope.hasGlobal("_SCRIPT_NAME"))
49
50
  for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
50
51
  referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueID}$SCRIPT_NAME$` : scriptName))
51
52
  if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
52
53
  for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
53
- referencePath.replaceWith(
54
- t.stringLiteral(
55
- 1 == scriptUser || 1 == scriptName ?
56
- `$${uniqueID}$FULL_SCRIPT_NAME$`
57
- : `${scriptUser}.${scriptName}`
54
+ if (1 == scriptUser || 1 == scriptName)
55
+ referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$FULL_SCRIPT_NAME$`))
56
+ else if (null == scriptUser) {
57
+ uniqueIdScriptUserNeeded = !0
58
+ referencePath.replaceWith(
59
+ t.binaryExpression(
60
+ "+",
61
+ t.identifier(`_${uniqueID}_SCRIPT_USER_`),
62
+ t.stringLiteral("." + scriptName)
63
+ )
58
64
  )
59
- )
65
+ } else referencePath.replaceWith(t.stringLiteral(`${scriptUser}.${scriptName}`))
60
66
  let functionDotPrototypeIsReferencedMultipleTimes = !1
61
67
  if (program.scope.hasGlobal("Function")) {
62
68
  const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
@@ -64,30 +70,30 @@ function transform(
64
70
  const referencePath = FunctionReferencePaths[0]
65
71
  assert(
66
72
  "MemberExpression" == referencePath.parent.type,
67
- "src/processScript/transform.ts:89:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
73
+ "src/processScript/transform.ts:105:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
68
74
  )
69
75
  assert(
70
76
  "Identifier" == referencePath.parent.property.type,
71
- "src/processScript/transform.ts:94:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
77
+ "src/processScript/transform.ts:110:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
72
78
  )
73
79
  assert(
74
80
  "prototype" == referencePath.parent.property.name,
75
- "src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
81
+ "src/processScript/transform.ts:115:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
76
82
  )
77
83
  referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
78
84
  } else {
79
85
  for (const referencePath of FunctionReferencePaths) {
80
86
  assert(
81
87
  "MemberExpression" == referencePath.parent.type,
82
- "src/processScript/transform.ts:107:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
88
+ "src/processScript/transform.ts:123:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
83
89
  )
84
90
  assert(
85
91
  "Identifier" == referencePath.parent.property.type,
86
- "src/processScript/transform.ts:112:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
92
+ "src/processScript/transform.ts:128:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
87
93
  )
88
94
  assert(
89
95
  "prototype" == referencePath.parent.property.name,
90
- "src/processScript/transform.ts:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
96
+ "src/processScript/transform.ts:133:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
91
97
  )
92
98
  functionDotPrototypeIsReferencedMultipleTimes = !0
93
99
  referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
@@ -123,12 +129,12 @@ function transform(
123
129
  const neededDbMethodLets = new Set()
124
130
  if (program.scope.hasGlobal("$db"))
125
131
  for (const referencePath of getReferencePathsToGlobal("$db", program)) {
126
- assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:171:69")
127
- assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:172:72")
132
+ assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:187:69")
133
+ assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:188:72")
128
134
  const databaseOpMethodName = referencePath.parentPath.node.property.name
129
135
  assert(
130
136
  validDBMethods.includes(databaseOpMethodName),
131
- `src/processScript/transform.ts:178:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
137
+ `src/processScript/transform.ts:194:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
132
138
  )
133
139
  if ("CallExpression" == referencePath.parentPath.parentPath?.type)
134
140
  referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
@@ -161,7 +167,7 @@ function transform(
161
167
  if (program.scope.hasGlobal("Object"))
162
168
  for (const referencePath of getReferencePathsToGlobal("Object", program))
163
169
  if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
164
- assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:225:64")
170
+ assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:241:64")
165
171
  if ("getPrototypeOf" == referencePath.parent.property.name) {
166
172
  referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
167
173
  needGetPrototypeOf = !0
@@ -171,7 +177,7 @@ function transform(
171
177
  if (program.scope.hasGlobal("console"))
172
178
  for (const referencePath of getReferencePathsToGlobal("console", program))
173
179
  if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
174
- assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:240:64")
180
+ assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:256:64")
175
181
  referencePath.parentPath.replaceWith(
176
182
  t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
177
183
  )
@@ -179,13 +185,13 @@ function transform(
179
185
  }
180
186
  const lastStatement = program.node.body.at(-1)
181
187
  let exportDefaultName
182
- assert(lastStatement, "src/processScript/transform.ts:254:27 program is empty")
188
+ assert(lastStatement, "src/processScript/transform.ts:270:27 program is empty")
183
189
  if ("ExportNamedDeclaration" == lastStatement.type) {
184
190
  program.node.body.pop()
185
191
  for (const specifier of lastStatement.specifiers) {
186
192
  assert(
187
193
  "ExportSpecifier" == specifier.type,
188
- `src/processScript/transform.ts:260:51 ${specifier.type} is currently unsupported`
194
+ `src/processScript/transform.ts:276:51 ${specifier.type} is currently unsupported`
189
195
  )
190
196
  const exportedName =
191
197
  "Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
@@ -261,6 +267,28 @@ function transform(
261
267
  [t.identifier("context"), t.identifier("args")],
262
268
  t.blockStatement([])
263
269
  )
270
+ if (uniqueIdScriptUserNeeded) {
271
+ const mainFunctionParams = mainFunction.params
272
+ mainFunction.params = [t.restElement(t.identifier(`_${uniqueID}_PARAMS_`))]
273
+ mainFunction.body.body.unshift(
274
+ t.variableDeclaration("let", [
275
+ t.variableDeclarator(t.arrayPattern(mainFunctionParams), t.identifier(`_${uniqueID}_PARAMS_`)),
276
+ t.variableDeclarator(
277
+ t.arrayPattern([t.identifier(`_${uniqueID}_SCRIPT_USER_`)]),
278
+ t.callExpression(
279
+ t.memberExpression(
280
+ t.memberExpression(
281
+ t.memberExpression(t.identifier(`_${uniqueID}_PARAMS_`), t.numericLiteral(0), !0),
282
+ t.identifier("this_script")
283
+ ),
284
+ t.identifier("split")
285
+ ),
286
+ [t.stringLiteral(".")]
287
+ )
288
+ )
289
+ ])
290
+ )
291
+ }
264
292
  program.node.body = [mainFunction]
265
293
  if (globalBlock.body.length) {
266
294
  ;(exports.size || liveExports.size) &&
@@ -286,11 +314,11 @@ function transform(
286
314
  let hoistedGlobalBlockFunctions = 0
287
315
  for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
288
316
  if ("VariableDeclaration" == globalBlockStatement.type) {
289
- assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:370:59")
317
+ assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:410:59")
290
318
  const declarator = globalBlockStatement.declarations[0]
291
319
  assert(
292
320
  "Identifier" == declarator.id.type,
293
- `src/processScript/transform.ts:374:51 declarator.id.type was "${declarator.id.type}"`
321
+ `src/processScript/transform.ts:414:51 declarator.id.type was "${declarator.id.type}"`
294
322
  )
295
323
  program.scope.crawl()
296
324
  if (program.scope.hasGlobal(declarator.id.name)) {
@@ -305,9 +333,9 @@ function transform(
305
333
  Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
306
334
  ) {
307
335
  const binding = program.scope.getBinding(declarator.id.name)
308
- assert(binding, "src/processScript/transform.ts:393:23")
336
+ assert(binding, "src/processScript/transform.ts:433:23")
309
337
  for (const referencePath of binding.referencePaths) {
310
- assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:396:56")
338
+ assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:436:56")
311
339
  referencePath.replaceWith(
312
340
  t.memberExpression(
313
341
  t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -351,16 +379,16 @@ function transform(
351
379
  } else globalBlockVariables.add(declarator.id.name)
352
380
  } else if ("ClassDeclaration" == globalBlockStatement.type) {
353
381
  program.scope.crawl()
354
- assert(globalBlockStatement.id, "src/processScript/transform.ts:447:37")
382
+ assert(globalBlockStatement.id, "src/processScript/transform.ts:487:37")
355
383
  if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
356
384
  globalBlock.body.splice(globalBlockIndex, 1)
357
385
  const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
358
386
  [globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
359
387
  program.scope.crawl()
360
388
  const binding = program.scope.getBinding(globalBlockStatement.id.name)
361
- assert(binding, "src/processScript/transform.ts:459:22")
389
+ assert(binding, "src/processScript/transform.ts:499:22")
362
390
  for (const referencePath of binding.referencePaths) {
363
- assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:462:55")
391
+ assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:502:55")
364
392
  referencePath.replaceWith(
365
393
  t.memberExpression(
366
394
  t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -527,7 +555,7 @@ function transform(
527
555
  }
528
556
  },
529
557
  ClassBody({ node: classBody, scope, parent }) {
530
- assert(t.isClass(parent), "src/processScript/transform.ts:629:30")
558
+ assert(t.isClass(parent), "src/processScript/transform.ts:669:30")
531
559
  let thisIsReferenced = !1
532
560
  for (const classMethod of classBody.body) {
533
561
  if ("ClassMethod" != classMethod.type) continue
@@ -633,23 +661,23 @@ function transform(
633
661
  }
634
662
  function processFakeSubscriptObject(fakeSubscriptObjectName) {
635
663
  for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
636
- assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:743:60")
664
+ assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:783:60")
637
665
  assert("Identifier" == referencePath.parent.property.type)
638
666
  assert(
639
667
  "MemberExpression" == referencePath.parentPath.parentPath?.node.type,
640
- "src/processScript/transform.ts:745:81"
668
+ "src/processScript/transform.ts:785:81"
641
669
  )
642
670
  assert(
643
671
  "Identifier" == referencePath.parentPath.parentPath.node.property.type,
644
- "src/processScript/transform.ts:746:83"
672
+ "src/processScript/transform.ts:786:83"
645
673
  )
646
674
  assert(
647
675
  /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
648
- `src/processScript/transform.ts:750:8 invalid user "${referencePath.parent.property.name}" in subscript`
676
+ `src/processScript/transform.ts:790:8 invalid user "${referencePath.parent.property.name}" in subscript`
649
677
  )
650
678
  assert(
651
679
  /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
652
- `src/processScript/transform.ts:755:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
680
+ `src/processScript/transform.ts:795:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
653
681
  )
654
682
  if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
655
683
  referencePath.parentPath.parentPath.replaceWith(
@@ -665,4 +693,4 @@ function transform(
665
693
  }
666
694
  }
667
695
  }
668
- export { transform as default, transform }
696
+ export { transform }
@@ -3,4 +3,3 @@
3
3
  * @param hackmudPath path to hackmud directory
4
4
  * @param script to pull in `user.name` format */
5
5
  export declare function pull(sourceFolderPath: string, hackmudPath: string, script: string): Promise<void>;
6
- export default pull;
package/pull.js CHANGED
@@ -8,4 +8,4 @@ async function pull(sourceFolderPath, hackmudPath, script) {
8
8
  resolve(sourceFolderPath, user, name + ".js")
9
9
  )
10
10
  }
11
- export { pull as default, pull }
11
+ export { pull }
@@ -1,6 +1,6 @@
1
1
  import type { LaxPartial } from "@samual/lib";
2
2
  import type { Info } from ".";
3
- export type PushOptions = {
3
+ export type PushOptions = LaxPartial<{
4
4
  /** whether to do the minify step (defaults to `true`) */ minify: boolean;
5
5
  /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
6
6
  /** array of scripts in the format `foo.bar`
@@ -17,13 +17,12 @@ export type PushOptions = {
17
17
  * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
18
18
  */
19
19
  forceQuineCheats: boolean;
20
- };
20
+ }>;
21
21
  /** Push scripts from a source directory to the hackmud directory.
22
22
  *
23
23
  * Pushes files directly in the source folder to all users
24
- * @param sourceDirectory directory containing source code
25
- * @param hackmudDirectory directory created by hackmud containing user data including scripts
24
+ * @param sourcePath directory containing source code
25
+ * @param hackmudPath directory created by hackmud containing user data including scripts
26
26
  * @param options {@link PushOptions details}
27
27
  * @returns array of info on pushed scripts */
28
- export declare function push(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: LaxPartial<PushOptions>): Promise<Info[]>;
29
- export default push;
28
+ export declare function push(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats }?: PushOptions): Promise<Info[]>;
package/push.js CHANGED
@@ -1,10 +1,10 @@
1
1
  import { Cache } from "@samual/lib/Cache"
2
+ import { ensure, assert } from "@samual/lib/assert"
2
3
  import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
3
4
  import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
4
5
  import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
5
6
  import { readFile } from "fs/promises"
6
- import { basename, resolve, extname } from "path"
7
- import { supportedExtensions } from "./constants.js"
7
+ import { basename, resolve } from "path"
8
8
  import { processScript } from "./processScript/index.js"
9
9
  import "@babel/generator"
10
10
  import "@babel/parser"
@@ -29,9 +29,9 @@ import "@rollup/plugin-babel"
29
29
  import "@rollup/plugin-commonjs"
30
30
  import "@rollup/plugin-json"
31
31
  import "@rollup/plugin-node-resolve"
32
- import "@samual/lib/assert"
33
32
  import "prettier"
34
33
  import "rollup"
34
+ import "./constants.js"
35
35
  import "./processScript/minify.js"
36
36
  import "@samual/lib/spliceString"
37
37
  import "acorn"
@@ -43,227 +43,96 @@ import "import-meta-resolve"
43
43
  import "./processScript/transform.js"
44
44
  import "@samual/lib/clearObject"
45
45
  async function push(
46
- sourceDirectory,
47
- hackmudDirectory,
46
+ sourcePath,
47
+ hackmudPath,
48
48
  { scripts = ["*.*"], onPush = () => {}, minify = !0, mangleNames = !1, forceQuineCheats } = {}
49
49
  ) {
50
- const scriptNamesByUser = new Cache(_user => new Set()),
51
- wildScriptUsers = new Set(),
52
- wildUserScripts = new Set()
53
- let pushEverything = !1
54
- for (const fullScriptName of scripts) {
55
- const [user, scriptName] = fullScriptName.split(".")
56
- user && "*" != user ?
57
- scriptName && "*" != scriptName ?
58
- scriptNamesByUser.get(user).add(scriptName)
59
- : wildScriptUsers.add(user)
60
- : scriptName && "*" != scriptName ? wildUserScripts.add(scriptName)
61
- : (pushEverything = !0)
50
+ const [sourceFolder, hackmudFolder] = await Promise.all([
51
+ readDirectoryWithStats(sourcePath),
52
+ readDirectoryWithStats(hackmudPath)
53
+ ]),
54
+ sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
55
+ allUsers = new Set([
56
+ ...scripts
57
+ .map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:52:65"))
58
+ .filter(name => "*" != name),
59
+ ...sourceFolderFolders.map(({ name }) => name),
60
+ ...hackmudFolder.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
61
+ ...hackmudFolder
62
+ .filter(({ stats, name }) => stats.isFile() && name.endsWith(".key"))
63
+ .map(({ name }) => name.slice(0, -4))
64
+ ]),
65
+ usersToScriptsToPush = new Cache(_user => new Map()),
66
+ scriptNamesToUsers = new Cache(_scriptName => new Set())
67
+ for (const script of scripts) {
68
+ const [user, scriptName] = script.split(".")
69
+ assert(user, "src/push.ts:69:16")
70
+ assert(scriptName, "src/push.ts:70:22")
71
+ "*" == user ? scriptNamesToUsers.set(scriptName, allUsers) : scriptNamesToUsers.get(scriptName).add(user)
62
72
  }
63
- const usersByGlobalScriptsToPush = new Cache(_user => new Set()),
64
- allInfo = [],
65
- scriptNamesAlreadyPushedByUser = new Cache(_user => new Set())
66
- let sourceDirectoryDirents
67
- if (wildUserScripts.size || pushEverything) {
68
- let hackmudDirectoryEntries
69
- ;[hackmudDirectoryEntries, sourceDirectoryDirents] = await Promise.all([
70
- readDirectoryWithStats(hackmudDirectory),
71
- readDirectoryWithStats(sourceDirectory)
72
- ])
73
- const allUsers = new Set([
74
- ...sourceDirectoryDirents.filter(({ stats }) => stats.isDirectory()).map(({ path }) => basename(path)),
75
- ...hackmudDirectoryEntries.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
76
- ...hackmudDirectoryEntries
77
- .filter(({ name, stats }) => stats.isFile() && name.endsWith(".key"))
78
- .map(({ name }) => name.slice(0, -4)),
79
- ...scriptNamesByUser.keys(),
80
- ...wildScriptUsers
81
- ])
82
- if (pushEverything) for (const user of allUsers) wildScriptUsers.add(user)
83
- else
84
- for (const user of allUsers) {
85
- const scriptNames = scriptNamesByUser.get(user)
86
- for (const scriptName of wildUserScripts) scriptNames.add(scriptName)
87
- }
73
+ const sourceFolderFiles = sourceFolder.filter(({ stats }) => stats.isFile()),
74
+ wildScriptUsers_ = scriptNamesToUsers.get("*")
75
+ scriptNamesToUsers.delete("*")
76
+ for (const { name, path } of [
77
+ ...sourceFolderFiles.filter(({ name }) => name.endsWith(".js")),
78
+ ...sourceFolderFiles.filter(({ name }) => name.endsWith(".ts"))
79
+ ]) {
80
+ const scriptName = name.slice(0, -3)
81
+ for (const user of [...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)])
82
+ usersToScriptsToPush.get(user).set(scriptName, path)
88
83
  }
89
84
  await Promise.all(
90
- [...wildScriptUsers].map(async user => {
91
- await readDirectoryWithStats(resolve(sourceDirectory, user)).then(
92
- async entries => {
93
- await Promise.all(
94
- entries.map(async ({ stats, name, path }) => {
95
- if (name.endsWith(".d.ts")) return
96
- const extension = extname(name)
97
- if (stats.isFile() && supportedExtensions.includes(extension)) {
98
- const scriptName = basename(name, extension),
99
- { script: minifiedCode } = await processScript(
100
- await readFile(path, { encoding: "utf-8" }),
101
- {
102
- minify,
103
- scriptUser: user,
104
- scriptName,
105
- filePath: path,
106
- mangleNames,
107
- forceQuineCheats
108
- }
109
- ),
110
- info = {
111
- file: `${user}/${name}`,
112
- users: [user],
113
- minLength: countHackmudCharacters(minifiedCode),
114
- error: void 0
115
- }
116
- scriptNamesAlreadyPushedByUser.get(user).add(scriptName)
117
- allInfo.push(info)
118
- await writeFilePersistent(
119
- resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
120
- minifiedCode
121
- )
122
- onPush(info)
123
- }
124
- })
125
- )
126
- },
127
- error => {
128
- if ("ENOENT" != error.code) throw error
129
- }
130
- )
85
+ sourceFolderFolders.map(async ({ name: user, path }) => {
86
+ const files = (await readDirectoryWithStats(path)).filter(({ stats }) => stats.isFile()),
87
+ scriptFiles = [
88
+ ...files.filter(({ name }) => name.endsWith(".js")),
89
+ ...files.filter(({ name }) => name.endsWith(".ts"))
90
+ ]
91
+ for (const { name, path } of scriptFiles) {
92
+ const scriptName = name.slice(0, -3)
93
+ ;[...wildScriptUsers_, ...scriptNamesToUsers.get(scriptName)].includes(user) &&
94
+ usersToScriptsToPush.get(user).set(scriptName, path)
95
+ }
131
96
  })
132
97
  )
98
+ for (const [scriptName, users] of scriptNamesToUsers)
99
+ for (const user of users)
100
+ if (!usersToScriptsToPush.get(user).has(scriptName))
101
+ throw Error(`Could not find script ${user}.${scriptName} to push`)
102
+ const pathsToUsers = new Cache(_path => new Set())
103
+ for (const [user, scriptsToPush] of usersToScriptsToPush)
104
+ for (const path of scriptsToPush.values()) pathsToUsers.get(path).add(user)
105
+ const allInfo = []
133
106
  await Promise.all(
134
- [...scriptNamesByUser].map(async ([user, scripts]) => {
135
- wildScriptUsers.has(user) ||
136
- (await Promise.all(
137
- [...scripts].map(async scriptName => {
138
- let code, fileName, filePath
139
- for (const extension of supportedExtensions)
140
- try {
141
- fileName = `${scriptName}${extension}`
142
- code = await readFile((filePath = resolve(sourceDirectory, user, fileName)), {
143
- encoding: "utf-8"
144
- })
145
- break
146
- } catch {}
147
- if (code) {
148
- const { script: minifiedCode } = await processScript(code, {
149
- minify,
150
- scriptUser: user,
151
- scriptName,
152
- filePath,
153
- mangleNames,
154
- forceQuineCheats
155
- }),
156
- info = {
157
- file: `${user}/${fileName}`,
158
- users: [user],
159
- minLength: countHackmudCharacters(minifiedCode),
160
- error: void 0
161
- }
162
- allInfo.push(info)
163
- await writeFilePersistent(
164
- resolve(hackmudDirectory, user, "scripts", scriptName + ".js"),
165
- minifiedCode
166
- )
167
- onPush(info)
168
- } else usersByGlobalScriptsToPush.get(scriptName).add(user)
169
- })
170
- ))
171
- })
172
- )
173
- await (wildScriptUsers.size ?
174
- Promise.all(
175
- (sourceDirectoryDirents || (await readDirectoryWithStats(sourceDirectory))).map(
176
- async ({ path, stats, name }) => {
177
- if (name.endsWith(".d.ts")) return
178
- const extension = extname(name)
179
- if (!stats.isFile() || !supportedExtensions.includes(extension)) return
180
- const scriptName = basename(name, extension),
181
- usersToPushTo = [...wildScriptUsers, ...usersByGlobalScriptsToPush.get(scriptName)].filter(
182
- user => !scriptNamesAlreadyPushedByUser.get(user).has(scriptName)
183
- )
184
- if (!usersToPushTo.length) return
185
- const uniqueID = Math.floor(Math.random() * 2 ** 52)
186
- .toString(36)
187
- .padStart(11, "0"),
188
- { script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf-8" }), {
189
- minify,
190
- scriptUser: !0,
191
- scriptName,
192
- uniqueID,
193
- filePath: path,
194
- mangleNames,
195
- forceQuineCheats
196
- }),
197
- info = {
198
- file: name,
199
- users: usersToPushTo,
200
- minLength: countHackmudCharacters(minifiedCode),
201
- error: void 0
202
- }
203
- await Promise.all(
204
- usersToPushTo.map(user =>
205
- writeFilePersistent(
206
- resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
207
- minifiedCode
208
- .replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
209
- .replace(
210
- RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
211
- `${user}.${scriptName}`
212
- )
213
- )
214
- )
107
+ [...pathsToUsers].map(async ([path, [...users]]) => {
108
+ const scriptName = basename(path.slice(0, -3)),
109
+ uniqueID = Math.floor(Math.random() * 2 ** 52)
110
+ .toString(36)
111
+ .padStart(11, "0"),
112
+ { script: minifiedCode } = await processScript(await readFile(path, { encoding: "utf8" }), {
113
+ minify,
114
+ scriptUser: !0,
115
+ scriptName,
116
+ uniqueID,
117
+ filePath: path,
118
+ mangleNames,
119
+ forceQuineCheats
120
+ }),
121
+ info = { path, users, characterCount: countHackmudCharacters(minifiedCode), error: void 0 }
122
+ await Promise.all(
123
+ users.map(user =>
124
+ writeFilePersistent(
125
+ resolve(hackmudPath, user, `scripts/${scriptName}.js`),
126
+ minifiedCode
127
+ .replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
128
+ .replace(RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"), `${user}.${scriptName}`)
215
129
  )
216
- allInfo.push(info)
217
- onPush(info)
218
- }
130
+ )
219
131
  )
220
- )
221
- : Promise.all(
222
- [...usersByGlobalScriptsToPush].map(async ([scriptName, users]) => {
223
- let code, fileName, filePath
224
- for (const extension of supportedExtensions)
225
- try {
226
- fileName = `${scriptName}${extension}`
227
- code = await readFile((filePath = resolve(sourceDirectory, fileName)), { encoding: "utf-8" })
228
- break
229
- } catch {}
230
- if (code) {
231
- const uniqueID = Math.floor(Math.random() * 2 ** 52)
232
- .toString(36)
233
- .padStart(11, "0"),
234
- { script: minifiedCode } = await processScript(code, {
235
- minify,
236
- scriptUser: !0,
237
- scriptName,
238
- uniqueID,
239
- filePath,
240
- mangleNames,
241
- forceQuineCheats
242
- }),
243
- info = {
244
- file: fileName,
245
- users: [...users],
246
- minLength: countHackmudCharacters(minifiedCode),
247
- error: void 0
248
- }
249
- await Promise.all(
250
- [...users].map(user =>
251
- writeFilePersistent(
252
- resolve(hackmudDirectory, user, `scripts/${scriptName}.js`),
253
- minifiedCode
254
- .replace(RegExp(`\\$${uniqueID}\\$SCRIPT_USER\\$`, "g"), user)
255
- .replace(
256
- RegExp(`\\$${uniqueID}\\$FULL_SCRIPT_NAME\\$`, "g"),
257
- `${user}.${scriptName}`
258
- )
259
- )
260
- )
261
- )
262
- allInfo.push(info)
263
- onPush(info)
264
- }
265
- })
266
- ))
132
+ allInfo.push(info)
133
+ onPush(info)
134
+ })
135
+ )
267
136
  return allInfo
268
137
  }
269
- export { push as default, push }
138
+ export { push }
@@ -2,4 +2,3 @@ export declare function syncMacros(hackmudPath: string): Promise<{
2
2
  macrosSynced: number;
3
3
  usersSynced: number;
4
4
  }>;
5
- export default syncMacros;
package/syncMacros.js CHANGED
@@ -12,7 +12,7 @@ async function syncMacros(hackmudPath) {
12
12
  case ".macros":
13
13
  {
14
14
  const [lines, date] = await Promise.all([
15
- readFile(resolve(hackmudPath, file.name), { encoding: "utf-8" }).then(file =>
15
+ readFile(resolve(hackmudPath, file.name), { encoding: "utf8" }).then(file =>
16
16
  file.split("\n")
17
17
  ),
18
18
  stat(resolve(hackmudPath, file.name)).then(({ mtime }) => mtime)
@@ -40,4 +40,4 @@ async function syncMacros(hackmudPath) {
40
40
  for (const user of users) writeFile(resolve(hackmudPath, user + ".macros"), macroFile)
41
41
  return { macrosSynced, usersSynced: users.length }
42
42
  }
43
- export { syncMacros as default, syncMacros }
43
+ export { syncMacros }