sandstone-cli 0.6.6 → 1.0.1

package/lib/build/{buildProject.js → index.js}

@@ -1,49 +1,22 @@
-"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 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 delete_empty_1 = __importDefault(require("delete-empty"));
-const pe = new pretty_error_1.default();
+import path from 'path';
+import * as os from 'os';
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import PrettyError from 'pretty-error';
+import walk from 'klaw';
+import chalk from 'chalk';
+import AdmZip from 'adm-zip';
+import deleteEmpty from 'delete-empty';
+const pe = new PrettyError();
 // Return the hash of a string
 function hash(stringToHash) {
-    return crypto_1.default.createHash('md5').update(stringToHash).digest('hex');
+    return crypto.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) => {
+            fs.mkdir(dirPath, { recursive: true }, (err) => {
                 if (err)
                     reject(err);
                 resolve();
@@ -55,32 +28,6 @@ async function mkDir(dirPath) {
     }
 }
 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 diffSet(tree1, tree2);
-}
 /**
  *
  * @param worldName The name of the world
@@ -93,12 +40,12 @@ async function getClientWorldPath(worldName, minecraftPath = undefined) {
         mcPath = minecraftPath;
     }
     else {
-        mcPath = await getClientPath();
+        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);
+    const savesPath = path.join(mcPath, 'saves');
+    const worldPath = path.join(savesPath, worldName);
+    if (!fs.existsSync(worldPath)) {
+        const existingWorlds = (await fs.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;
@@ -110,17 +57,21 @@ async function getClientPath() {
     function getMCPath() {
         switch (os.platform()) {
             case 'win32':
-                return path_1.default.join(os.homedir(), 'AppData/Roaming/.minecraft');
+                return path.join(os.homedir(), 'AppData/Roaming/.minecraft');
             case 'darwin':
-                return path_1.default.join(os.homedir(), 'Library/Application Support/minecraft');
+                return path.join(os.homedir(), 'Library/Application Support/minecraft');
             case 'linux':
             default:
-                return path_1.default.join(os.homedir(), '.minecraft');
+                return path.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.');
+    try {
+        await fs.stat(mcPath);
+    }
+    catch (e) {
+        console.warn('Unable to locate the .minecraft folder. Will not be able to export to client.');
+        return undefined;
     }
     return mcPath;
 }
@@ -131,18 +82,20 @@ async function getClientPath() {
  *
  * @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 }, changedFiles) {
+async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandstoneConfigFolder }) {
     var _a, _b, _c, _d, _e, _f, _g;
-    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');
+    const sandstoneConfig = (await import(path.join(sandstoneConfigFolder, 'sandstone.config.ts'))).default;
+    const { scripts } = sandstoneConfig;
+    let { saveOptions } = sandstoneConfig;
+    if (saveOptions === undefined)
+        saveOptions = {};
+    const outputFolder = path.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'));
+            const sshOptions = JSON.stringify(await fs.readFile(cliOptions.ssh || saveOptions.ssh, 'utf8'));
             // TODO: implement SFTP
             return {
                 readFile: async (relativePath, encoding = 'utf8') => { },
@@ -152,16 +105,16 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
         }
         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),
+            readFile: async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(serverPath, relativePath), encoding),
             writeFile: async (relativePath, contents) => {
                 if (contents === undefined) {
-                    await fs_extra_1.default.unlink(path_1.default.join(serverPath, relativePath));
+                    await fs.unlink(path.join(serverPath, relativePath));
                 }
                 else {
-                    await fs_extra_1.default.writeFile(path_1.default.join(serverPath, relativePath), contents);
+                    await fs.writeFile(path.join(serverPath, relativePath), contents);
                 }
             },
-            remove: async (relativePath) => await fs_extra_1.default.remove(path_1.default.join(serverPath, relativePath))
+            remove: async (relativePath) => await fs.remove(path.join(serverPath, relativePath))
         };
     })() : undefined;
     let worldName = cliOptions.world || saveOptions.world;
@@ -211,80 +164,19 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
     // 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.
+    // Finally, let's import from the index.
     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);
-                }
-            }
+    let sandstonePack;
+    const filePath = path.join(absProjectFolder, 'index.ts');
+    try {
+        // Sometimes, a file might not exist because it has been deleted.
+        if (await fs.pathExists(filePath)) {
+            sandstonePack = (await import(filePath)).default;
         }
     }
-    // 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);
+    catch (e) {
+        logError(e, absProjectFolder);
+        error = true;
     }
     if (error) {
         return;
@@ -293,11 +185,11 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
     // 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 = {};
-    const cacheFile = path_1.default.join(rootFolder, '.sandstone', 'cache.json');
+    const cacheFile = path.join(rootFolder, '.sandstone', 'cache.json');
     if (cache === undefined) {
         let oldCache;
         try {
-            const fileRead = await fs_extra_1.default.readFile(cacheFile, 'utf8');
+            const fileRead = await fs.readFile(cacheFile, 'utf8');
             if (fileRead) {
                 oldCache = JSON.parse(fileRead);
             }
@@ -349,23 +241,23 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                     return;
                 }
                 // Not in cache: write to disk
-                const realPath = path_1.default.join(outputFolder, relativePath);
-                await mkDir(path_1.default.dirname(realPath));
-                return await fs_extra_1.default.writeFile(realPath, content);
+                const realPath = path.join(outputFolder, relativePath);
+                await mkDir(path.dirname(realPath));
+                return await fs.writeFile(realPath, content);
             }
         })
     });
     async function handleResources(packType) {
-        const working = path_1.default.join(rootFolder, 'resources', packType);
+        const working = path.join(rootFolder, 'resources', packType);
         let exists = false;
         try {
-            await fs_extra_1.default.access(working);
+            await fs.access(working);
             exists = true;
         }
         catch (e) { }
         if (exists) {
-            for await (const file of (0, klaw_1.default)(path_1.default.join(rootFolder, 'resources', packType), { filter: (_path) => {
-                    const relativePath = path_1.default.join(packType, _path.split(working)[1]);
+            for await (const file of walk(path.join(rootFolder, 'resources', packType), { filter: (_path) => {
+                    const relativePath = path.join(packType, _path.split(working)[1]);
                     let pathPass = true;
                     if (fileExclusions && fileExclusions.existing) {
                         for (const exclude of fileExclusions.existing) {
@@ -374,9 +266,9 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                     }
                     return pathPass;
                 } })) {
-                const relativePath = path_1.default.join(packType, file.path.split(working)[1]);
+                const relativePath = path.join(packType, file.path.split(working)[1]);
                 try {
-                    let content = await fs_extra_1.default.readFile(file.path);
+                    let content = await fs.readFile(file.path);
                     if (fileHandlers) {
                         for (const handler of fileHandlers) {
                             if (handler.path.test(relativePath)) {
@@ -390,9 +282,9 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                     newCache[relativePath] = hashValue;
                     if (cache[relativePath] !== hashValue) {
                         // Not in cache: write to disk
-                        const realPath = path_1.default.join(outputFolder, relativePath);
-                        await mkDir(path_1.default.dirname(realPath));
-                        await fs_extra_1.default.writeFile(realPath, content);
+                        const realPath = path.join(outputFolder, relativePath);
+                        await mkDir(path.dirname(realPath));
+                        await fs.writeFile(realPath, content);
                     }
                 }
                 catch (e) { }
@@ -400,11 +292,11 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
         }
     }
     async function archiveOutput(packType) {
-        const input = path_1.default.join(outputFolder, packType.type);
-        if ((await fs_extra_1.default.readdir(input)).length !== 0) {
-            const archive = new adm_zip_1.default();
+        const input = path.join(outputFolder, packType.type);
+        if ((await fs.readdir(input)).length !== 0) {
+            const archive = new AdmZip();
             await archive.addLocalFolderPromise(input, {});
-            await archive.writeZipPromise(`${path_1.default.join(outputFolder, 'archives', `${packName}_${packType.type}`)}.zip`, { overwrite: true });
+            await archive.writeZipPromise(`${path.join(outputFolder, 'archives', `${packName}_${packType.type}`)}.zip`, { overwrite: true });
             return true;
         }
         return false;
@@ -413,15 +305,15 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
     if (!cliOptions.production) {
         for await (const _packType of packTypes) {
             const packType = _packType[1];
-            const outputPath = path_1.default.join(outputFolder, packType.type);
-            await fs_extra_1.default.ensureDir(outputPath);
+            const outputPath = path.join(outputFolder, packType.type);
+            await fs.ensureDir(outputPath);
             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) => {
+                await packType.handleOutput('output', async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(outputPath, relativePath), encoding), async (relativePath, contents) => {
                     if (contents === undefined) {
-                        await fs_extra_1.default.unlink(path_1.default.join(outputPath, relativePath));
+                        await fs.unlink(path.join(outputPath, relativePath));
                     }
                     else {
-                        await fs_extra_1.default.writeFile(path_1.default.join(outputPath, relativePath), contents);
+                        await fs.writeFile(path.join(outputPath, relativePath), contents);
                     }
                 });
             }
@@ -431,10 +323,10 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                 archivedOutput = await archiveOutput(packType);
             }
             // Handle client
-            if (!(server && packType.networkSides === 'server')) {
+            if (!(server && packType.networkSides === 'server') && clientPath) {
                 let fullClientPath;
                 if (worldName) {
-                    fullClientPath = path_1.default.join(clientPath, packType.clientPath);
+                    fullClientPath = path.join(clientPath, packType.clientPath);
                     try {
                         fullClientPath = fullClientPath.replace('$packName$', packName);
                     }
@@ -445,7 +337,7 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                     catch { }
                 }
                 else {
-                    fullClientPath = path_1.default.join(clientPath, packType.rootPath);
+                    fullClientPath = path.join(clientPath, packType.rootPath);
                     try {
                         fullClientPath = fullClientPath.replace('$packName$', packName);
                     }
@@ -453,20 +345,20 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                 }
                 if (packType.archiveOutput) {
                     if (archivedOutput) {
-                        await fs_extra_1.default.copyFile(`${path_1.default.join(outputFolder, 'archives', `${packName}_${packType.type}`)}.zip`, `${fullClientPath}.zip`);
+                        await fs.copyFile(`${path.join(outputFolder, 'archives', `${packName}_${packType.type}`)}.zip`, `${fullClientPath}.zip`);
                     }
                 }
                 else {
-                    await fs_extra_1.default.remove(fullClientPath);
-                    await fs_extra_1.default.copy(outputPath, fullClientPath);
+                    await fs.remove(fullClientPath);
+                    await fs.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) => {
+                    await packType.handleOutput('client', async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(clientPath, relativePath), encoding), async (relativePath, contents) => {
                         if (contents === undefined) {
-                            fs_extra_1.default.unlink(path_1.default.join(clientPath, relativePath));
+                            fs.unlink(path.join(clientPath, relativePath));
                         }
                         else {
-                            await fs_extra_1.default.writeFile(path_1.default.join(clientPath, relativePath), contents);
+                            await fs.writeFile(path.join(clientPath, relativePath), contents);
                         }
                     });
                 }
@@ -479,12 +371,12 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
                 }
                 catch { }
                 if (packType.archiveOutput && archivedOutput) {
-                    await server.writeFile(await fs_extra_1.default.readFile(`${outputPath}.zip`, 'utf8'), `${serverPath}.zip`);
+                    await server.writeFile(await fs.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));
+                    for await (const file of walk(outputPath)) {
+                        await server.writeFile(path.join(serverPath, file.path.split(outputPath)[1]), await fs.readFile(file.path));
                     }
                 }
                 if (packType.handleOutput) {
@@ -495,14 +387,14 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
     }
     else {
         for await (const packType of packTypes) {
-            const outputPath = path_1.default.join(outputFolder, packType.type);
+            const outputPath = path.join(outputFolder, 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) => {
+                await packType.handleOutput('output', async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(outputPath, relativePath), encoding), async (relativePath, contents) => {
                     if (contents === undefined) {
-                        await fs_extra_1.default.unlink(path_1.default.join(outputPath, relativePath));
+                        await fs.unlink(path.join(outputPath, relativePath));
                     }
                     else {
-                        await fs_extra_1.default.writeFile(path_1.default.join(outputPath, relativePath), contents);
+                        await fs.writeFile(path.join(outputPath, relativePath), contents);
                     }
                 });
             }
@@ -516,13 +408,13 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
     const oldFilesNames = new Set(Object.keys(cache));
     Object.keys(newCache).forEach(name => oldFilesNames.delete(name));
     for await (const name of oldFilesNames) {
-        await fs_extra_1.default.rm(path_1.default.join(outputFolder, name));
+        await fs.rm(path.join(outputFolder, name));
     }
-    await (0, delete_empty_1.default)(outputFolder);
+    await deleteEmpty(outputFolder);
     // Override old cache
     cache = newCache;
     // Write the cache to disk
-    await fs_extra_1.default.writeFile(cacheFile, JSON.stringify(cache));
+    await fs.writeFile(cacheFile, JSON.stringify(cache));
     // Run the afterAll script
     await ((_g = scripts === null || scripts === void 0 ? void 0 : scripts.afterAll) === null || _g === void 0 ? void 0 : _g.call(scripts));
 }
@@ -532,22 +424,19 @@ async function _buildProject(cliOptions, { absProjectFolder, rootFolder, sandsto
  * @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, changedFiles) {
+export async function buildProject(options, folders) {
     try {
-        await _buildProject(options, folders, changedFiles);
+        await _buildProject(options, folders);
     }
     catch (err) {
         console.log(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('  ' + chalk.bgRed.white('BuildError') + chalk.gray(':'), `While loading "${file}", the following error happened:\n`);
         }
         debugger;
         console.error(pe.render(err));

package/lib/commands/build.d.ts

@@ -1,29 +1,18 @@
-import { Command } from '@oclif/command';
-export default class Build extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        dry: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        verbose: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        namespace: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        world: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        root: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        clientPath: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        serverPath: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        name: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        description: import("@oclif/command/lib/flags").IOptionFlag<string | undefined>;
-        formatVersion: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
-        fullTrace: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        strictErrors: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        production: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        autoReload: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
-    };
-    static args: {
-        name: string;
-        description: string;
-        required: boolean;
-        default: string;
-    }[];
-    run(): Promise<void>;
-}
+type BuildOptions = {
+    dry?: boolean;
+    verbose?: boolean;
+    root?: boolean;
+    fullTrace?: boolean;
+    strictErrors?: boolean;
+    production?: boolean;
+    path: string;
+    configPath: string;
+    name?: string;
+    namespace?: string;
+    world?: string;
+    clientPath?: string;
+    serverPath?: string;
+    ssh?: any;
+};
+export declare function buildCommand(opts: BuildOptions): Promise<void>;
+export {};

package/lib/commands/build.js

@@ -1,32 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const buildProject_1 = require("../build/buildProject");
-const utils_1 = require("../utils");
-const path_1 = __importDefault(require("path"));
-const watch_1 = __importDefault(require("./watch"));
-class Build extends command_1.Command {
-    async run() {
-        const { args, flags } = this.parse(Build);
-        const folders = (0, utils_1.getProjectFolders)(args.path);
-        // Register ts-node
-        const tsConfigPath = path_1.default.join(folders.rootFolder, 'tsconfig.json');
-        require('ts-node').register({
-            transpileOnly: !flags.strictErrors,
-            project: tsConfigPath,
-        });
-        (0, buildProject_1.buildProject)(flags, folders);
-    }
+import { register as tsEval } from 'ts-node';
+import path from 'path';
+import { getProjectFolders } from '../utils.js';
+import { buildProject } from '../build/index.js';
+export async function buildCommand(opts) {
+    const folders = getProjectFolders(opts.path);
+    tsEval({
+        transpileOnly: !opts.strictErrors,
+        project: path.join(folders.rootFolder, 'tsconfig.json'),
+    });
+    buildProject(opts, folders);
 }
-exports.default = Build;
-Build.description = 'Build the packs. ⛏';
-Build.examples = [
-    '$ sand build',
-    '$ sand build --verbose',
-    '$ sand build --verbose --dry',
-];
-Build.flags = watch_1.default.flags;
-Build.args = watch_1.default.args;

package/lib/commands/create.d.ts

@@ -1,24 +1,8 @@
-import { Command, flags } from '@oclif/command';
-export default class Create extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        yarn: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        npm: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        library: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        version: flags.IOptionFlag<string | undefined>;
-        'pack-name': flags.IOptionFlag<string | undefined>;
-        namespace: flags.IOptionFlag<string | undefined>;
-        'save-root': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        world: flags.IOptionFlag<string | undefined>;
-        'server-path': flags.IOptionFlag<string | undefined>;
-        'client-path': flags.IOptionFlag<string | undefined>;
-    };
-    static args: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
-    run(): Promise<void>;
-}
+type CreateOptions = {
+    root: boolean;
+    world?: string;
+    clientPath?: string;
+    serverPath?: string;
+};
+export declare function createCommand(_project: string, opts: CreateOptions): Promise<void>;
+export {};