sandstone-cli 0.5.4 → 0.6.1

package/README.md

@@ -19,7 +19,7 @@ $ npm install -g sandstone-cli
 $ sand COMMAND
 running command...
 $ sand (-v|--version|version)
-sandstone-cli/0.5.4 linux-x64 node-v16.7.0
+sandstone-cli/0.6.1 linux-x64 node-v16.19.0
 $ sand --help [COMMAND]
 USAGE
   $ sand COMMAND
@@ -36,7 +36,7 @@ USAGE
 
 ## `sand build PATH CONFIG-PATH`
 
-Build the datapack. ⛏
+Build the packs. ⛏
 
 ```
 USAGE
@@ -47,7 +47,7 @@ ARGUMENTS
   CONFIG-PATH  [default: .] Path of the sandstone.config.ts folder.
 
 OPTIONS
-  -d, --dry                      Do not save the datapack. Mostly useful with `verbose`.
+  -d, --dry                      Do not save the pack. Mostly useful with `verbose`.
   -h, --help                     show CLI help
   -p, --production               Runs Sandstone in production mode. This sets process.env.SANDSTONE_ENV to "production".
   -v, --verbose                  Log all resulting resources: functions, advancements...
@@ -55,23 +55,23 @@ OPTIONS
   --autoReload=port              Automatically reload your data pack in-game. Requires to open the world to LAN with
                                  cheats enabled, and to specify the port.
 
+  --clientPath=clientPath        Path of the client folder. Override the value specified in the configuration file.
+
   --description=description      Description of the data pack. Override the value specified in the configuration file.
 
   --formatVersion=formatVersion  Pack format version. Override the value specified in the configuration file.
 
   --fullTrace                    Show the full stack trace on errors.
 
-  --minecraftPath=minecraftPath  Path of the .minecraft folder. Override the value specified in the configuration file.
-
   --name=name                    Name of the data pack. Override the value specified in the configuration file.
 
   --namespace=namespace          The default namespace. Override the value specified in the configuration file.
 
-  --path=path                    The path to save the data pack at. Override the value specified in the configuration
+  --root                         Save the data pack & resource pack in the .minecraft/datapacks &
+                                 .minecraft/resource_packs folders. Override the value specified in the configuration
                                  file.
 
-  --root                         Save the data pack in the `.minecraft/datapacks` folder. Override the value specified
-                                 in the configuration file.
+  --serverPath=serverPath        Path of the server folder. Override the value specified in the configuration file.
 
   --strictErrors                 Stop data pack compilation on type errors.
 
@@ -84,7 +84,7 @@ EXAMPLES
   $ sand build --verbose --dry
 ```
 
-_See code: [src/commands/build.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.5.4/src/commands/build.ts)_
+_See code: [src/commands/build.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.6.1/src/commands/build.ts)_
 
 ## `sand create PROJECT-NAME`
 
@@ -98,26 +98,27 @@ ARGUMENTS
   PROJECT-NAME  Name of the project folder. This is not the name of the data pack.
 
 OPTIONS
-  -d, --datapack-name=datapack-name  The name of the data pack.
-  -h, --help                         show CLI help
-  -n, --namespace=namespace          The default namespace that will be used.
-  -p, --custom-path=custom-path      The path to save the data pack at. Not compatible with --save-root and --world.
+  -c, --client-path=client-path  The client path to write packs at.
+  -d, --pack-name=pack-name      The name of the data pack.
+  -h, --help                     show CLI help
+  -n, --namespace=namespace      The default namespace that will be used.
 
-  -r, --save-root                    Save the data pack in the .minecraft/datapacks folder. Not compatible with --world
-                                     and --custom-path.
+  -r, --save-root                Save the data pack & resource pack in the .minecraft/datapacks &
+                                 .minecraft/resource_packs folders. Not compatible with --world.
 
-  -w, --world=world                  The world to save the data pack in. Not compatible with --save-root and
-                                     --custom-path.
+  -s, --server-path=server-path  The server path to write the server-side packs at. Not compatible with --world.
 
-  --npm                              Use npm.
+  -w, --world=world              The world to save the packs in. Not compatible with --save-root or --server
 
-  --yarn                             Use yarn instead of npm.
+  --npm                          Use npm.
+
+  --yarn                         Use yarn instead of npm.
 
 EXAMPLE
-  $ sand create my-datapack
+  $ sand create my-pack
 ```
 
-_See code: [src/commands/create.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.5.4/src/commands/create.ts)_
+_See code: [src/commands/create.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.6.1/src/commands/create.ts)_
 
 ## `sand help [COMMAND]`
 
@@ -159,11 +160,11 @@ EXAMPLES
   $ sand update --cli --sandstone --skip
 ```
 
-_See code: [src/commands/update.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.5.4/src/commands/update.ts)_
+_See code: [src/commands/update.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.6.1/src/commands/update.ts)_
 
 ## `sand watch PATH CONFIG-PATH`
 
-Build the datapack, and rebuild it on file change. ⛏
+Build the packs, and rebuild them on file change. ⛏
 
 ```
 USAGE
@@ -174,7 +175,7 @@ ARGUMENTS
   CONFIG-PATH  [default: .] Path of the sandstone.config.ts folder.
 
 OPTIONS
-  -d, --dry                      Do not save the datapack. Mostly useful with `verbose`.
+  -d, --dry                      Do not save the pack. Mostly useful with `verbose`.
   -h, --help                     show CLI help
   -p, --production               Runs Sandstone in production mode. This sets process.env.SANDSTONE_ENV to "production".
   -v, --verbose                  Log all resulting resources: functions, advancements...
@@ -182,23 +183,23 @@ OPTIONS
   --autoReload=port              Automatically reload your data pack in-game. Requires to open the world to LAN with
                                  cheats enabled, and to specify the port.
 
+  --clientPath=clientPath        Path of the client folder. Override the value specified in the configuration file.
+
   --description=description      Description of the data pack. Override the value specified in the configuration file.
 
   --formatVersion=formatVersion  Pack format version. Override the value specified in the configuration file.
 
   --fullTrace                    Show the full stack trace on errors.
 
-  --minecraftPath=minecraftPath  Path of the .minecraft folder. Override the value specified in the configuration file.
-
   --name=name                    Name of the data pack. Override the value specified in the configuration file.
 
   --namespace=namespace          The default namespace. Override the value specified in the configuration file.
 
-  --path=path                    The path to save the data pack at. Override the value specified in the configuration
+  --root                         Save the data pack & resource pack in the .minecraft/datapacks &
+                                 .minecraft/resource_packs folders. Override the value specified in the configuration
                                  file.
 
-  --root                         Save the data pack in the `.minecraft/datapacks` folder. Override the value specified
-                                 in the configuration file.
+  --serverPath=serverPath        Path of the server folder. Override the value specified in the configuration file.
 
   --strictErrors                 Stop data pack compilation on type errors.
 
@@ -211,5 +212,5 @@ EXAMPLES
   $ sand watch --verbose --dry
 ```
 
-_See code: [src/commands/watch.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.5.4/src/commands/watch.ts)_
+_See code: [src/commands/watch.ts](https://github.com/TheMrZZ/sandstone-cli/blob/v0.6.1/src/commands/watch.ts)_
 <!-- commandsstop -->

package/lib/{buildProject.d.ts → build/buildProject.d.ts}

@@ -1,9 +1,10 @@
-import { ProjectFolders } from './utils';
+import { ProjectFolders } from '../utils';
 export declare type BuildOptions = {
     world?: string;
     root?: boolean;
-    path?: string;
-    minecraftPath?: string;
+    clientPath?: string;
+    serverPath?: string;
+    ssh?: string;
     namespace?: string;
     name?: string;
     description?: string;
@@ -19,5 +20,7 @@ export declare type BuildOptions = {
  * @param options The options to build the project with.
  *
  * @param projectFolder The folder of the project. It needs a sandstone.config.ts, and it or one of its parent needs a package.json.
+ *
+ * @param changedFiles The files that changed since the last build.
  */
-export declare function buildProject(options: BuildOptions, folders: ProjectFolders): Promise<void>;
+export declare function buildProject(options: BuildOptions, folders: ProjectFolders, resourceTypes: string[], changedFiles?: string[]): Promise<void>;

package/lib/build/buildProject.js

@@ -0,0 +1,461 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProject = void 0;
+const path_1 = __importDefault(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("util");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const pretty_error_1 = __importDefault(require("pretty-error"));
+const klaw_1 = __importDefault(require("klaw"));
+const madge_1 = __importDefault(require("madge"));
+const graph_1 = require("./graph");
+const chalk_1 = __importDefault(require("chalk"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const pe = new pretty_error_1.default();
+// Return the hash of a string
+function hash(stringToHash) {
+    return crypto_1.default.createHash('md5').update(stringToHash).digest('hex');
+}
+// Recursively create a directory, without failing if it already exists
+async function mkDir(dirPath) {
+    try {
+        await new Promise((resolve, reject) => {
+            fs_extra_1.default.mkdir(dirPath, { recursive: true }, (err) => {
+                if (err)
+                    reject(err);
+                resolve();
+            });
+        });
+    }
+    catch (error) {
+        // Directory already exists
+    }
+}
+let cache = {};
+const dependenciesCache = new graph_1.DependencyGraph({});
+const fileResources = new Map();
+function getNewModules(dependenciesGraph, rawFiles, projectFolder) {
+    const rawFilesPath = rawFiles.map(({ path }) => path);
+    // Get only the new modules
+    const newModules = [...dependenciesGraph.nodes.values()].filter((node) => rawFilesPath.includes(path_1.default.join(projectFolder, node.name)));
+    // Get their dependants, as a set to avoid duplicates
+    const newModulesDependencies = new Set(newModules.flatMap((node) => [...node.getDependsOn({ recursive: true, includeSelf: true })]));
+    // Sort them by number of dependencies, and return them
+    return [...newModulesDependencies].sort((a, b) => a.getDependencies({ recursive: true }).size - b.getDependencies({ recursive: true }).size);
+}
+/**
+ * Returns a set of all values present in set1 and not present in set2.
+ */
+function diffSet(set1, set2) {
+    return [...set1].filter((element) => !set2.has(element));
+}
+/**
+ * Returns a map of all key/value present in map1 and not present in map2.
+ */
+function diffMap(map1, map2) {
+    return new Map([...map1.entries()].filter(([key, value]) => !map2.has(key)));
+}
+function diffResources(tree1, tree2) {
+    return tree1.diff(tree2);
+}
+/**
+ *
+ * @param worldName The name of the world
+ * @param minecraftPath The optional location of the .minecraft folder.
+ * If left unspecified, the .minecraft will be found automatically.
+ */
+async function getClientWorldPath(worldName, minecraftPath = undefined) {
+    let mcPath;
+    if (minecraftPath) {
+        mcPath = minecraftPath;
+    }
+    else {
+        mcPath = await getClientPath();
+    }
+    const savesPath = path_1.default.join(mcPath, 'saves');
+    const worldPath = path_1.default.join(savesPath, worldName);
+    if (!fs_extra_1.default.existsSync(worldPath)) {
+        const existingWorlds = (await fs_extra_1.default.readdir(savesPath, { withFileTypes: true })).filter((f) => f.isDirectory).map((f) => f.name);
+        throw new Error(`Unable to locate the "${worldPath}" folder. Word ${worldName} does not exists. List of existing worlds: ${JSON.stringify(existingWorlds, null, 2)}`);
+    }
+    return worldPath;
+}
+/**
+ * Get the .minecraft path
+ */
+async function getClientPath() {
+    function getMCPath() {
+        switch (os.platform()) {
+            case 'win32':
+                return path_1.default.join(os.homedir(), 'AppData/Roaming/.minecraft');
+            case 'darwin':
+                return path_1.default.join(os.homedir(), 'Library/Application Support/minecraft');
+            case 'linux':
+            default:
+                return path_1.default.join(os.homedir(), '.minecraft');
+        }
+    }
+    const mcPath = getMCPath();
+    if (!await fs_extra_1.default.stat(mcPath)) {
+        throw new Error('Unable to locate the .minecraft folder. Please specify it manually.');
+    }
+    return mcPath;
+}
+/**
+ * Build the project, but might throw errors.
+ *
+ * @param cliOptions The options to build the project with.
+ *
+ * @param projectFolder The folder of the project. It needs a sandstone.config.ts, and it or one of its parent needs a package.json.
+ */
+async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandstoneConfigFolder }, resourceTypes, changedFiles) {
+    var _a, _b, _c, _d, _e;
+    const sandstoneLocation = path_1.default.join(rootFolder, 'node_modules/sandstone/');
+    // First, read sandstone.config.ts to get all properties
+    const sandstoneConfig = require(path_1.default.join(sandstoneConfigFolder, 'sandstone.config.ts')).default;
+    const { saveOptions, scripts } = sandstoneConfig;
+    const outputFolder = path_1.default.join(rootFolder, '.sandstone', 'output');
+    /// OPTIONS ///
+    const clientPath = !cliOptions.production ? (cliOptions.clientPath || saveOptions.clientPath || await getClientPath()) : undefined;
+    const server = !cliOptions.production && (cliOptions.serverPath || saveOptions.serverPath || cliOptions.ssh || saveOptions.ssh) ? await (async () => {
+        if (cliOptions.ssh || saveOptions.ssh) {
+            const sshOptions = JSON.stringify(await fs_extra_1.default.readFile(cliOptions.ssh || saveOptions.ssh, 'utf8'));
+            // TODO: implement SFTP
+            return {
+                readFile: async (relativePath, encoding = 'utf8') => { },
+                writeFile: async (relativePath, contents) => { },
+                remove: async (relativePath) => { },
+            };
+        }
+        const serverPath = cliOptions.serverPath || saveOptions.serverPath;
+        return {
+            readFile: async (relativePath, encoding = 'utf8') => await fs_extra_1.default.readFile(path_1.default.join(serverPath, relativePath), encoding),
+            writeFile: async (relativePath, contents) => {
+                if (contents === undefined) {
+                    await fs_extra_1.default.unlink(path_1.default.join(serverPath, relativePath));
+                }
+                else {
+                    await fs_extra_1.default.writeFile(path_1.default.join(serverPath, relativePath), contents);
+                }
+            },
+            remove: async (relativePath) => await fs_extra_1.default.remove(path_1.default.join(serverPath, relativePath))
+        };
+    })() : undefined;
+    let worldName = cliOptions.world || saveOptions.world;
+    // Make sure the world exists
+    if (worldName && !cliOptions.production) {
+        await getClientWorldPath(worldName, clientPath);
+    }
+    const root = cliOptions.root !== undefined ? cliOptions.root : saveOptions.root;
+    const packName = (_a = cliOptions.name) !== null && _a !== void 0 ? _a : sandstoneConfig.name;
+    if (worldName && root) {
+        throw new Error(`Expected only 'world' or 'root'. Got both.`);
+    }
+    // Important /!\: The below if statements, which set environment variables, must run before importing any Sandstone file.
+    // Set the pack ID environment variable
+    // Set production/development mode
+    if (cliOptions.production) {
+        process.env.SANDSTONE_ENV = 'production';
+    }
+    else {
+        process.env.SANDSTONE_ENV = 'development';
+    }
+    if (sandstoneConfig.packUid) {
+        process.env.PACK_UID = sandstoneConfig.packUid;
+    }
+    // Set the namespace
+    const namespace = cliOptions.namespace || sandstoneConfig.namespace;
+    if (namespace) {
+        process.env.NAMESPACE = namespace;
+    }
+    const { onConflict } = sandstoneConfig;
+    if (onConflict) {
+        if (onConflict.default) {
+            process.env[`GENERAL_CONFLICT_STRATEGY`] = onConflict.default;
+        }
+        for (const resource of resourceTypes) {
+            if (onConflict[resource]) {
+                process.env[`${resource.toUpperCase()}_CONFLICT_STRATEGY`] = onConflict[resource];
+            }
+        }
+    }
+    // JSON indentation
+    process.env.INDENTATION = saveOptions.indentation;
+    // Pack mcmeta
+    process.env.PACK_OPTIONS = JSON.stringify(sandstoneConfig.packs);
+    // Configure error display
+    if (!cliOptions.fullTrace) {
+        pe.skipNodeFiles();
+    }
+    /// IMPORTING USER CODE ///
+    // The configuration is ready.
+    // Now, let's run the beforeAll script
+    await ((_b = scripts === null || scripts === void 0 ? void 0 : scripts.beforeAll) === null || _b === void 0 ? void 0 : _b.call(scripts));
+    // Finally, let's import all .ts & .js files under ./src.
+    let error = false;
+    // Get the list of all files
+    const rawFiles = [];
+    for await (const file of (0, klaw_1.default)(absProjectFolder)) {
+        rawFiles.push(file);
+    }
+    const changedFilesPaths = changedFiles === null || changedFiles === void 0 ? void 0 : changedFiles.map(file => ({ path: file }));
+    /**
+     * 1. Update dependency graphs
+     * 2. Delete all cache & resources for files dependent from the changed files
+     * 3. Import all changed files, & their dependents
+     * 4. Save only newly created resources
+     */
+    const graph = await (0, madge_1.default)(rawFiles.map(f => f.path).filter(f => !f.endsWith('.json')), {
+        fileExtensions: ['.ts', '.cts', '.mts', '.tsx', '.js', '.jsx', '.cjs', '.mjs', '.json'],
+        includeNpm: false,
+        baseDir: absProjectFolder,
+        detectiveOptions: {
+            es6: {
+                skipTypeImports: true,
+            },
+            ts: {
+                skipTypeImports: true,
+            },
+        },
+    });
+    // This dependencies graph is only partial.
+    const dependenciesGraph = new graph_1.DependencyGraph(graph.obj());
+    // Update the global dependency graph by merging it with the new one.
+    dependenciesCache.merge(dependenciesGraph);
+    // Transform resolved dependents into a flat list of files, and sort them by their number of dependencies
+    const newModules = getNewModules(dependenciesCache, changedFilesPaths !== null && changedFilesPaths !== void 0 ? changedFilesPaths : rawFiles, absProjectFolder);
+    const { sandstonePack } = require(sandstoneLocation);
+    // If files changed, we need to clean the cache & delete the related resources
+    if (changedFiles) {
+        for (const node of newModules) {
+            // For each changed file, we need to reset the require cache
+            delete require.cache[path_1.default.join(absProjectFolder, node.name)];
+            // Then we need to delete all resources the file created
+            const oldResources = fileResources.get(node.name);
+            if (oldResources) {
+                for (const resource of oldResources.resources) {
+                    sandstonePack.core.deleteResource(resource.path, resource.resourceType);
+                }
+            }
+        }
+    }
+    // Now, let's build the file & its dependents. First files to be built are the ones with less dependencies.
+    for (const node of newModules) {
+        const modulePath = path_1.default.join(absProjectFolder, node.name);
+        const currentResources = {
+            resources: new Set([...sandstonePack.core.resourceNodes]),
+            objectives: new Set([...sandstonePack.objectives.entries()])
+        };
+        // We have a module, let's require it!
+        const filePath = path_1.default.resolve(modulePath);
+        try {
+            // Sometimes, a file might not exist because it has been deleted.
+            if (await fs_extra_1.default.pathExists(filePath)) {
+                require(filePath);
+            }
+        }
+        catch (e) {
+            logError(e, node.name);
+            error = true;
+        }
+        // Now, find the resources that were added by this file & store them.
+        // This will be used if those files are changed later.
+        const newResources = {
+            resources: diffResources(sandstonePack.core.resourceNodes, currentResources.resources),
+            objectives: diffSet(sandstonePack.objectives, currentResources.objectives),
+        };
+        fileResources.set(node.name, newResources);
+    }
+    if (error) {
+        return;
+    }
+    /// SAVING RESULTS ///
+    // Setup the cache if it doesn't exist.
+    // This cache is here to avoid writing files on disk when they did not change.
+    const newCache = {};
+    if (cache === undefined) {
+        cache = {};
+    }
+    // Save the pack
+    // Run the beforeSave script (TODO: This is where sandstone-server will remove restart env vars)
+    await ((_c = scripts === null || scripts === void 0 ? void 0 : scripts.beforeSave) === null || _c === void 0 ? void 0 : _c.call(scripts));
+    const packTypes = await sandstonePack.save({
+        // Additional parameters
+        dryRun: cliOptions.dry,
+        verbose: cliOptions.verbose,
+        fileHandler: (_d = saveOptions.customFileHandler) !== null && _d !== void 0 ? _d : (async ({ relativePath, content, contentSummary }) => {
+            // We hash the relative path alongside the content to ensure unique hash.
+            const hashValue = hash(contentSummary + relativePath);
+            // Add to new cache.
+            newCache[relativePath] = hashValue;
+            if (cache[relativePath] === hashValue) {
+                // Already in cache - skip
+                return;
+            }
+            // Not in cache: write to disk
+            const realPath = path_1.default.join(rootFolder, relativePath);
+            await mkDir(path_1.default.dirname(realPath));
+            return await fs_extra_1.default.writeFile(realPath, content);
+        })
+    });
+    async function archiveOutput(packType, outputPath) {
+        const archive = new adm_zip_1.default();
+        await archive.addLocalFolderPromise(outputPath, {});
+        await archive.writeZipPromise(`${outputPath}.zip`, { overwrite: true });
+    }
+    // TODO: implement linking to make the cache more useful when not archiving.
+    if (!cliOptions.production) {
+        for (const packType of packTypes) {
+            const outputPath = path_1.default.join(rootFolder, '.sandstone/output/archives', `${packName}_${packType.type}`);
+            if (packType.handleOutput) {
+                await packType.handleOutput('output', async (relativePath, encoding = 'utf8') => await fs_extra_1.default.readFile(path_1.default.join(outputPath, relativePath), encoding), async (relativePath, contents) => {
+                    if (contents === undefined) {
+                        await fs_extra_1.default.unlink(path_1.default.join(outputPath, relativePath));
+                    }
+                    else {
+                        await fs_extra_1.default.writeFile(path_1.default.join(outputPath, relativePath), contents);
+                    }
+                });
+            }
+            if (packType.archiveOutput) {
+                archiveOutput(packType, outputPath);
+            }
+            // Handle client
+            if (!(server && packType.networkSides === 'server')) {
+                let fullClientPath;
+                if (worldName) {
+                    fullClientPath = path_1.default.join(clientPath, packType.clientPath);
+                    try {
+                        fullClientPath = fullClientPath.replace('$packName$', packName);
+                    }
+                    catch { }
+                    try {
+                        fullClientPath = fullClientPath.replace('$worldName$', worldName);
+                    }
+                    catch { }
+                }
+                else {
+                    fullClientPath = path_1.default.join(clientPath, packType.rootPath);
+                    try {
+                        fullClientPath = fullClientPath.replace('$packName$', packName);
+                    }
+                    catch { }
+                }
+                if (packType.archiveOutput) {
+                    await fs_extra_1.default.copyFile(`${outputPath}.zip`, `${fullClientPath}.zip`);
+                }
+                else {
+                    await fs_extra_1.default.remove(fullClientPath);
+                    await fs_extra_1.default.copy(outputPath, fullClientPath);
+                }
+                if (packType.handleOutput) {
+                    await packType.handleOutput('client', async (relativePath, encoding = 'utf8') => await fs_extra_1.default.readFile(path_1.default.join(clientPath, relativePath), encoding), async (relativePath, contents) => {
+                        if (contents === undefined) {
+                            fs_extra_1.default.unlink(path_1.default.join(clientPath, relativePath));
+                        }
+                        else {
+                            await fs_extra_1.default.writeFile(path_1.default.join(clientPath, relativePath), contents);
+                        }
+                    });
+                }
+            }
+            // Handle server
+            if (server && (packType.networkSides === 'server' || packType.networkSides === 'both')) {
+                let serverPath = packType.serverPath;
+                try {
+                    serverPath = serverPath.replace('$packName$', packName);
+                }
+                catch { }
+                if (packType.archiveOutput) {
+                    await server.writeFile(await fs_extra_1.default.readFile(`${outputPath}.zip`, 'utf8'), `${serverPath}.zip`);
+                }
+                else {
+                    server.remove(serverPath);
+                    for await (const file of (0, klaw_1.default)(outputPath)) {
+                        await server.writeFile(path_1.default.join(serverPath, file.path.split(outputPath)[1]), await fs_extra_1.default.readFile(file.path));
+                    }
+                }
+                if (packType.handleOutput) {
+                    await packType.handleOutput('server', server.readFile, server.writeFile);
+                }
+            }
+        }
+    }
+    else {
+        for (const packType of packTypes) {
+            const outputPath = path_1.default.join(rootFolder, '.sandstone/output/archives', `${packName}_${packType.type}`);
+            if (packType.handleOutput) {
+                await packType.handleOutput('output', async (relativePath, encoding = 'utf8') => await fs_extra_1.default.readFile(path_1.default.join(outputPath, relativePath), encoding), async (relativePath, contents) => {
+                    if (contents === undefined) {
+                        await fs_extra_1.default.unlink(path_1.default.join(outputPath, relativePath));
+                    }
+                    else {
+                        await fs_extra_1.default.writeFile(path_1.default.join(outputPath, relativePath), contents);
+                    }
+                });
+            }
+            if (packType.archiveOutput) {
+                archiveOutput(packType, outputPath);
+            }
+        }
+    }
+    // Delete old files that aren't cached anymore
+    const oldFilesNames = new Set(Object.keys(cache));
+    Object.keys(newCache).forEach(name => oldFilesNames.delete(name));
+    await Promise.allSettled([...oldFilesNames.values()].map(name => (0, util_1.promisify)(fs_extra_1.default.rm)(path_1.default.join(outputFolder, name))));
+    // Override old cache
+    cache = newCache;
+    // Run the afterAll script
+    await ((_e = scripts === null || scripts === void 0 ? void 0 : scripts.afterAll) === null || _e === void 0 ? void 0 : _e.call(scripts));
+}
+/**
+ * Build the project. Will log errors and never throw any.
+ *
+ * @param options The options to build the project with.
+ *
+ * @param projectFolder The folder of the project. It needs a sandstone.config.ts, and it or one of its parent needs a package.json.
+ *
+ * @param changedFiles The files that changed since the last build.
+ */
+async function buildProject(options, folders, resourceTypes, changedFiles) {
+    try {
+        await _buildProject(options, folders, resourceTypes, changedFiles);
+    }
+    catch (err) {
+        logError(err);
+    }
+}
+exports.buildProject = buildProject;
+function logError(err, file) {
+    if (err) {
+        if (file) {
+            console.error('  ' + chalk_1.default.bgRed.white('BuildError') + chalk_1.default.gray(':'), `While loading "${file}", the following error happened:\n`);
+        }
+        console.error(pe.render(err));
+    }
+}
+process.on('unhandledRejection', logError);
+process.on('uncaughtException', logError);