@appsemble/cli 0.23.4 → 0.23.6

package/lib/{getBlockConfigFromTypeScript.js → config.js}

@@ -1,8 +1,108 @@
-import { relative } from 'node:path';
-import { AppsembleError, logger } from '@appsemble/node-utils';
+import { existsSync } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { inspect } from 'node:util';
+import { AppsembleError, getWorkspaces, logger, readData } from '@appsemble/node-utils';
+import { prefixBlockURL } from '@appsemble/utils';
+import chalk from 'chalk';
 import { parse } from 'comment-parser';
+import { cosmiconfig } from 'cosmiconfig';
 import normalizePath from 'normalize-path';
 import { createFormatter, createParser, SchemaGenerator, ts } from 'ts-json-schema-generator';
+/**
+ * Get the build configuration from a project directory.
+ *
+ * @param dir The directory in which to search for the configuration file.
+ * @returns The configuration.
+ */
+export async function getProjectBuildConfig(dir) {
+    const explorer = cosmiconfig('appsemble', { stopDir: dir });
+    const found = await explorer.search(dir);
+    let foundInParent;
+    if (!found) {
+        foundInParent = await explorer.search(dirname(dir));
+        if (!foundInParent) {
+            throw new AppsembleError(`No Appsemble configuration file found searching ${dir}`);
+        }
+    }
+    const { config, filepath } = found || foundInParent;
+    logger.info(`Found configuration file: ${filepath}`);
+    const [pkg] = await readData(join(dir, 'package.json'));
+    if (!pkg.private) {
+        logger.warn(`It is ${chalk.underline.yellow('highly recommended')} to set “${chalk.green('"private"')}: ${chalk.cyan('true')}” in package.json`);
+    }
+    let longDescription;
+    if (existsSync(join(dir, 'README.md'))) {
+        longDescription = await readFile(join(dir, 'README.md'), 'utf8');
+    }
+    const result = {
+        description: pkg.description,
+        longDescription,
+        name: pkg.name,
+        version: pkg.version,
+        dir,
+        ...config,
+    };
+    logger.verbose(`Resolved project configuration: ${inspect(result, { colors: true })}`);
+    return result;
+}
+/**
+ * Discover Appsemble projects based on workspaces in a monorepo.
+ *
+ * Both Lerna and Yarn workspaces are supported.
+ *
+ * @param root The project root in which to find workspaces.
+ * @returns Discovered Appsemble projects.
+ */
+export async function getProjectsBuildConfigs(root) {
+    const dirs = await getWorkspaces(root);
+    const projectBuildConfigs = await Promise.all(dirs
+        .concat(root)
+        .map((path) => getProjectBuildConfig(path))
+        // Ignore non-project workspaces.
+        .map((p) => p.catch(() => null)));
+    return projectBuildConfigs.filter(Boolean);
+}
+/**
+ * Get the TypeScript program for a given path.
+ *
+ * @param path The path for which to get the TypeScript program.
+ * @returns The TypeScript program.
+ */
+function getProgram(path) {
+    const diagnosticHost = {
+        getNewLine: () => ts.sys.newLine,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getCanonicalFileName: (x) => x,
+    };
+    const tsConfigPath = ts.findConfigFile(path, ts.sys.fileExists);
+    const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    if (error) {
+        throw new AppsembleError(ts.formatDiagnostic(error, diagnosticHost));
+    }
+    if (!config.files || !config.include) {
+        config.files = ts.sys.readDirectory(path, ['.ts', '.tsx']).map((f) => relative(path, f));
+    }
+    const { errors, fileNames, options } = ts.parseJsonConfigFileContent(config, ts.sys, path, undefined, tsConfigPath);
+    // Filter: 'rootDir' is expected to contain all source files.
+    const diagnostics = errors.filter(({ code }) => code !== 6059);
+    if (diagnostics.length) {
+        throw new AppsembleError(ts.formatDiagnosticsWithColorAndContext(diagnostics, diagnosticHost));
+    }
+    options.noEmit = true;
+    delete options.out;
+    delete options.outDir;
+    delete options.outFile;
+    delete options.declaration;
+    delete options.declarationDir;
+    delete options.declarationMap;
+    const program = ts.createProgram(fileNames, options);
+    const preEmitDiagnostics = ts.getPreEmitDiagnostics(program);
+    if (preEmitDiagnostics.length) {
+        throw new AppsembleError(ts.formatDiagnosticsWithColorAndContext(preEmitDiagnostics, diagnosticHost));
+    }
+    return program;
+}
 /**
  * Get the tsdoc comment for a TypeScript node.
  *
@@ -104,7 +204,7 @@ function processEvents(eventListenerInterface, eventEmitterInterface, checker) {
  *
  * @param program The TypeScript program from which to extract parameters.
  * @param iface The interface node from which to extract parameters.
- * @returns The JSON schema for the block parameters.
+ * @returns The JSON schema for the project parameters.
  */
 function processParameters(program, iface) {
     if (!iface) {
@@ -128,7 +228,7 @@ function processParameters(program, iface) {
     if (schema.definitions && !Object.keys(schema.definitions).length) {
         delete schema.definitions;
     }
-    // This is the tsdoc that has been added to the SDK to aid the block developer.
+    // This is the tsdoc that has been added to the SDK to aid the developer.
     delete schema.description;
     return schema;
 }
@@ -143,67 +243,22 @@ function processMessages(iface, checker) {
     return processInterface(iface, checker, (name, description) => [name, { description }]);
 }
 /**
- * Get the TypeScript program for a given path.
+ * Generate project implementations from the project metadata and TypeScript project.
  *
- * @param blockPath The path for which to get the TypeScript program.
- * @returns The TypeScript program.
- */
-function getProgram(blockPath) {
-    const diagnosticHost = {
-        getNewLine: () => ts.sys.newLine,
-        getCurrentDirectory: ts.sys.getCurrentDirectory,
-        getCanonicalFileName: (x) => x,
-    };
-    const tsConfigPath = ts.findConfigFile(blockPath, ts.sys.fileExists);
-    const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-    if (error) {
-        throw new AppsembleError(ts.formatDiagnostic(error, diagnosticHost));
-    }
-    if (!config.files || !config.include) {
-        config.files = ts.sys
-            .readDirectory(blockPath, ['.ts', '.tsx'])
-            .map((f) => relative(blockPath, f));
-    }
-    const { errors, fileNames, options } = ts.parseJsonConfigFileContent(config, ts.sys, blockPath, undefined, tsConfigPath);
-    // Filter: 'rootDir' is expected to contain all source files.
-    const diagnostics = errors.filter(({ code }) => code !== 6059);
-    if (diagnostics.length) {
-        throw new AppsembleError(ts.formatDiagnosticsWithColorAndContext(diagnostics, diagnosticHost));
-    }
-    options.noEmit = true;
-    delete options.out;
-    delete options.outDir;
-    delete options.outFile;
-    delete options.declaration;
-    delete options.declarationDir;
-    delete options.declarationMap;
-    const program = ts.createProgram(fileNames, options);
-    const preEmitDiagnostics = ts.getPreEmitDiagnostics(program);
-    if (preEmitDiagnostics.length) {
-        throw new AppsembleError(ts.formatDiagnosticsWithColorAndContext(preEmitDiagnostics, diagnosticHost));
-    }
-    return program;
-}
-/**
- * Generate a block manifest from the block metadata and TypeScript project.
+ * Uses the .appsemblerc file and the type definitions of the project.
  *
- * Uses the .appsemblerc file and the type definitions of the block.
- *
- * @param blockConfig The block configuration
- * @returns The block configuration appended from the TypeScript project.
+ * @param buildConfig The project build configuration
+ * @returns The project implementations from the TypeScript project.
  */
-export function getBlockConfigFromTypeScript(blockConfig) {
-    if ('actions' in blockConfig && 'events' in blockConfig && 'parameters' in blockConfig) {
-        return blockConfig;
-    }
-    logger.info(`Extracting data from TypeScript project ${blockConfig.dir}`);
-    const program = getProgram(blockConfig.dir);
+export function getProjectImplementations(buildConfig) {
+    logger.info(`Extracting data from TypeScript project ${buildConfig.dir}`);
+    const program = getProgram(buildConfig.dir);
     const checker = program.getTypeChecker();
     let actionInterface;
     let eventEmitterInterface;
     let eventListenerInterface;
     let messagesInterface;
-    let patametersInterface;
+    let parametersInterface;
     for (const sourceFile of program.getSourceFiles()) {
         const fileName = relative(process.cwd(), sourceFile.fileName);
         // Filter TypeScript default libs
@@ -254,10 +309,10 @@ export function getBlockConfigFromTypeScript(blockConfig) {
                         break;
                     case 'Parameters':
                         logger.info(`Found augmented interface 'Parameters' in '${loc}'`);
-                        if (patametersInterface) {
+                        if (parametersInterface) {
                             throw new AppsembleError(`Found duplicate interface 'Parameters' in '${loc}'`);
                         }
-                        patametersInterface = iface;
+                        parametersInterface = iface;
                         break;
                     case 'Messages':
                         logger.info(`Found augmented interface 'Messages' in '${loc}'`);
@@ -270,16 +325,57 @@ export function getBlockConfigFromTypeScript(blockConfig) {
         });
     }
     return {
-        actions: 'actions' in blockConfig ? blockConfig.actions : processActions(actionInterface, checker),
-        events: 'events' in blockConfig
-            ? blockConfig.events
+        actions: 'actions' in buildConfig ? buildConfig.actions : processActions(actionInterface, checker),
+        events: 'events' in buildConfig
+            ? buildConfig.events
             : processEvents(eventListenerInterface, eventEmitterInterface, checker),
-        parameters: 'parameters' in blockConfig
-            ? blockConfig.parameters
-            : processParameters(program, patametersInterface),
-        messages: 'messages' in blockConfig
-            ? blockConfig.messages
+        parameters: 'parameters' in buildConfig
+            ? buildConfig.parameters
+            : processParameters(program, parametersInterface),
+        messages: 'messages' in buildConfig
+            ? buildConfig.messages
             : processMessages(messagesInterface, checker),
     };
 }
-//# sourceMappingURL=getBlockConfigFromTypeScript.js.map
+/**
+ * Load a webpack configuration file.
+ *
+ * A webpack configuration file may export either an webpack configuration object, or a synchronous
+ * or asynchronous function which returns a webpack configuration object. This function supports
+ * all 3 use cases.
+ *
+ * @param buildConfig The project build config.
+ * @param mode The env that would be passed to webpack by invoking `webpack --env $env`.
+ * @param outputPath The path where the build will be output on disk.
+ * @returns The webpack configuration as exposed by the webpack configuration file.
+ */
+export async function getProjectWebpackConfig(buildConfig, mode, outputPath) {
+    let configPath;
+    if (buildConfig.webpack) {
+        configPath = join(buildConfig.dir, buildConfig.webpack);
+    }
+    else {
+        configPath = join(buildConfig.dir, 'webpack.config.js');
+        try {
+            await stat(configPath);
+        }
+        catch {
+            configPath = '@appsemble/webpack-config';
+        }
+    }
+    logger.info(`Using webpack config from ${configPath}`);
+    const publicPath = prefixBlockURL({ type: buildConfig.name, version: buildConfig.version }, '');
+    let config = await import(String(configPath));
+    config = await (config.default || config);
+    config = config instanceof Function ? await config(buildConfig, { mode, publicPath }) : config;
+    // Koa-webpack serves assets on the `output.path` path. Normally this field describes where to
+    // output the files on the file system. This is monkey patched to support usage with our dev
+    // server.
+    config.output = config.output || {};
+    config.output.path = outputPath || publicPath;
+    logger.verbose(`Patched webpack config output.path to ${config.output.path}`);
+    config.output.publicPath = publicPath;
+    logger.verbose(`Patched webpack config output.publicPath to ${config.output.publicPath}`);
+    return config;
+}
+//# sourceMappingURL=config.js.map

package/lib/{getBlockConfigFromTypeScript.test.js → config.test.js}

@@ -4,19 +4,19 @@ import { fileURLToPath } from 'node:url';
 import { AppsembleError, resolveFixture } from '@appsemble/node-utils';
 import { ts } from 'ts-json-schema-generator';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getBlockConfigFromTypeScript } from './getBlockConfigFromTypeScript.js';
+import { getProjectImplementations } from './config.js';
 beforeEach(() => {
     vi.spyOn(process, 'cwd').mockReturnValue(resolveFixture('.'));
 });
-describe('getBlockConfigFromTypeScript', () => {
+describe('getProjectImplementations', () => {
     it('should extract configuration from a TypeScript project', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             name: '',
             layout: 'float',
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+            dir: resolveFixture('getProjectImplementations/valid'),
         });
         expect(result).toStrictEqual({
             actions: { testAction: { description: undefined } },
@@ -62,87 +62,87 @@ describe('getBlockConfigFromTypeScript', () => {
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+            dir: resolveFixture('getProjectImplementations/valid'),
             name: '',
         };
-        const result = getBlockConfigFromTypeScript(input);
+        const result = getProjectImplementations(input);
         expect(result).toBe(input);
         expect(ts.createProgram).not.toHaveBeenCalled();
     });
     it('should prefer actions overrides over TypeScript actions', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             actions: {},
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+            dir: resolveFixture('getProjectImplementations/valid'),
             name: '',
         });
         expect(result.actions).toStrictEqual({});
     });
     it('should prefer events overrides over TypeScript events', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             events: { emit: { onSuccess: {} } },
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+            dir: resolveFixture('getProjectImplementations/valid'),
             name: '',
         });
         expect(result.events).toStrictEqual({ emit: { onSuccess: {} } });
     });
     it('should prefer parameters overrides over TypeScript parameters', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             parameters: { type: 'object' },
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/valid'),
+            dir: resolveFixture('getProjectImplementations/valid'),
             name: '',
         });
         expect(result.parameters).toStrictEqual({ type: 'object' });
     });
     it('should throw if duplicate Actions are found', () => {
-        expect(() => getBlockConfigFromTypeScript({
+        expect(() => getProjectImplementations({
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/duplicateActions'),
+            dir: resolveFixture('getProjectImplementations/duplicateActions'),
             name: '',
             version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'Actions' in 'getBlockConfigFromTypeScript/duplicateActions/index.ts:31'"));
+        })).toThrow(new AppsembleError("Found duplicate interface 'Actions' in 'getProjectImplementations/duplicateActions/index.ts:31'"));
     });
     it('should throw if duplicate EventEmitters are found', () => {
-        expect(() => getBlockConfigFromTypeScript({
+        expect(() => getProjectImplementations({
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/duplicateEventEmitters'),
+            dir: resolveFixture('getProjectImplementations/duplicateEventEmitters'),
             name: '',
             version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'EventEmitters' in 'getBlockConfigFromTypeScript/duplicateEventEmitters/index.ts:31'"));
+        })).toThrow(new AppsembleError("Found duplicate interface 'EventEmitters' in 'getProjectImplementations/duplicateEventEmitters/index.ts:31'"));
     });
     it('should throw if duplicate EventListeners are found', () => {
-        expect(() => getBlockConfigFromTypeScript({
+        expect(() => getProjectImplementations({
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/duplicateEventListeners'),
+            dir: resolveFixture('getProjectImplementations/duplicateEventListeners'),
             name: '',
             version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'EventListeners' in 'getBlockConfigFromTypeScript/duplicateEventListeners/index.ts:31'"));
+        })).toThrow(new AppsembleError("Found duplicate interface 'EventListeners' in 'getProjectImplementations/duplicateEventListeners/index.ts:31'"));
     });
     it('should throw if duplicate Parameters are found', () => {
-        expect(() => getBlockConfigFromTypeScript({
+        expect(() => getProjectImplementations({
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/duplicateParameters'),
+            dir: resolveFixture('getProjectImplementations/duplicateParameters'),
             name: '',
             version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'Parameters' in 'getBlockConfigFromTypeScript/duplicateParameters/index.ts:31'"));
+        })).toThrow(new AppsembleError("Found duplicate interface 'Parameters' in 'getProjectImplementations/duplicateParameters/index.ts:31'"));
     });
     it('should handle fontawesome icons', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/fontawesomeParameters'),
+            dir: resolveFixture('getProjectImplementations/fontawesomeParameters'),
             name: '',
             version: '1.33.7',
         });
@@ -162,26 +162,26 @@ describe('getBlockConfigFromTypeScript', () => {
     });
     it('should handle TypeScript pre emit diagnostics', () => {
         function fn() {
-            getBlockConfigFromTypeScript({
+            getProjectImplementations({
                 name: '',
                 layout: 'float',
                 version: '1.33.7',
                 webpack: '',
                 output: '',
-                dir: resolveFixture('getBlockConfigFromTypeScript/tsError'),
+                dir: resolveFixture('getProjectImplementations/tsError'),
             });
         }
         expect(fn).toThrow(AppsembleError);
         expect(fn).toThrow(/'unused' is declared but its value is never read/);
     });
     it('should extract comments', () => {
-        const result = getBlockConfigFromTypeScript({
+        const result = getProjectImplementations({
             name: '',
             layout: 'float',
             version: '1.33.7',
             webpack: '',
             output: '',
-            dir: resolveFixture('getBlockConfigFromTypeScript/comments'),
+            dir: resolveFixture('getProjectImplementations/comments'),
         });
         expect(result).toStrictEqual({
             actions: {
@@ -223,7 +223,7 @@ describe('getBlockConfigFromTypeScript', () => {
         const blocksDir = new URL('../../../blocks/', import.meta.url);
         it.each(readdirSync(blocksDir))('%s', (name) => {
             const dir = fileURLToPath(new URL(name, blocksDir));
-            const result = getBlockConfigFromTypeScript({
+            const result = getProjectImplementations({
                 name,
                 version: '',
                 output: '',
@@ -234,4 +234,4 @@ describe('getBlockConfigFromTypeScript', () => {
         });
     });
 });
-//# sourceMappingURL=getBlockConfigFromTypeScript.test.js.map
+//# sourceMappingURL=config.test.js.map

package/lib/project.d.ts

@@ -0,0 +1,12 @@
+import { type ProjectBuildConfig, type ProjectImplementations } from '@appsemble/types';
+import { type BuildResult } from 'esbuild';
+import FormData from 'form-data';
+export declare function buildProject(config: ProjectBuildConfig): Promise<BuildResult>;
+/**
+ * Configure the payload for a new project upload.
+ *
+ * @param buildConfig The project configuration
+ * @returns The payload that should be sent to the endpoint.
+ */
+export declare function makeProjectPayload(buildConfig: ProjectBuildConfig): Promise<[FormData, ProjectImplementations]>;
+export declare function publishProject(buildConfig: ProjectBuildConfig, url: string, ignoreConflict?: boolean): Promise<void>;

package/lib/project.js

@@ -0,0 +1,145 @@
+import { createReadStream } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, extname, join, relative, resolve as resolvePath } from 'node:path';
+import { inspect } from 'node:util';
+import { AppsembleError, logger, opendirSafe, readData } from '@appsemble/node-utils';
+import { compareStrings } from '@appsemble/utils';
+import axios from 'axios';
+import { build } from 'esbuild';
+import FormData from 'form-data';
+import { getProjectImplementations } from './config.js';
+export async function buildProject(config) {
+    const buildOptions = {
+        entryPoints: ['index.ts'],
+        bundle: true,
+        write: false,
+        absWorkingDir: join(config.dir),
+        loader: {
+            '.png': 'dataurl',
+            '.svg': 'dataurl',
+        },
+        logLevel: 'info',
+        minify: true,
+    };
+    logger.info(`Building ${config.name}@${config.version} 🔨`);
+    const buildResult = await build(buildOptions);
+    if (buildResult.errors.length > 0) {
+        throw new AppsembleError(String(buildResult.errors));
+    }
+    return buildResult;
+}
+/**
+ * Configure the payload for a new project upload.
+ *
+ * @param buildConfig The project configuration
+ * @returns The payload that should be sent to the endpoint.
+ */
+export async function makeProjectPayload(buildConfig) {
+    const { dir, output } = buildConfig;
+    const distPath = output ? resolvePath(dir, output) : undefined;
+    const form = new FormData();
+    const gatheredData = {};
+    const { description, layout, longDescription, name, version, visibility } = buildConfig;
+    const { actions, events, messages, parameters } = getProjectImplementations(buildConfig);
+    const files = await readdir(dir);
+    const icon = files.find((entry) => entry.match(/^icon\.(png|svg)$/));
+    function append(field, value) {
+        if (value) {
+            const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+            logger.verbose(`Using ${field}: ${inspect(value, { colors: true, depth: 20 })}`);
+            form.append(field, serialized);
+            gatheredData[field] = value;
+        }
+        else {
+            logger.silly(`Skipping parameter ${field}`);
+        }
+    }
+    if (visibility) {
+        append('visibility', visibility);
+    }
+    append('actions', actions);
+    append('description', description);
+    append('longDescription', longDescription);
+    append('events', events);
+    append('layout', layout);
+    append('name', name);
+    append('parameters', parameters);
+    append('version', version);
+    if (icon) {
+        const iconPath = join(dir, icon);
+        logger.info(`Using icon: ${iconPath}`);
+        form.append('icon', createReadStream(iconPath));
+        gatheredData.iconUrl = basename(iconPath, extname(iconPath));
+    }
+    if (messages) {
+        if (!files.includes('i18n')) {
+            throw new AppsembleError('This block has messages defined, but the message files could not be found. Try running extract-messages');
+        }
+        const messageKeys = Object.keys(messages).sort(compareStrings);
+        const messagesResult = {};
+        const messagesPath = join(dir, 'i18n');
+        const translations = (await readdir(messagesPath)).map((language) => language.toLowerCase());
+        if (!translations.includes('en.json')) {
+            throw new AppsembleError('Could not find ‘en.json’. Try running extract-messages');
+        }
+        const duplicates = translations.filter((language, index) => translations.indexOf(language) !== index);
+        if (duplicates.length) {
+            throw new AppsembleError(`Found duplicate language codes: ‘${duplicates.join('’, ')}`);
+        }
+        for (const languageFile of translations.filter((t) => t.endsWith('.json'))) {
+            const language = basename(languageFile, '.json');
+            const languagePath = join(messagesPath, languageFile);
+            const [m] = await readData(languagePath);
+            const languageKeys = Object.keys(m).sort(compareStrings);
+            if (languageKeys.length !== messageKeys.length ||
+                languageKeys.some((key) => !messageKeys.includes(key))) {
+                throw new AppsembleError(`‘${languagePath}’ contains mismatching message keys. Try running extract-messages`);
+            }
+            logger.info(`Including ${language} translations from ‘${languagePath}’`);
+            messagesResult[language] = m;
+        }
+        form.append('messages', JSON.stringify(messagesResult));
+        gatheredData.messages = messagesResult;
+    }
+    if (files.includes('examples')) {
+        await opendirSafe(join(dir, 'examples'), async (file, stat) => {
+            if (!stat.isFile() || !file.endsWith('.yaml')) {
+                throw new AppsembleError(`Expected ${file} to be a YAML file`);
+            }
+            logger.info(`Adding example file ${file}`);
+            form.append('examples', await readFile(file, 'utf8'));
+            gatheredData.examples = [...(gatheredData.examples || []), basename(file, extname(file))];
+        }, { allowMissing: true });
+    }
+    if (distPath) {
+        await opendirSafe(distPath, (fullpath, stat) => {
+            if (!stat.isFile()) {
+                return;
+            }
+            const relativePath = relative(distPath, fullpath);
+            const realPath = relative(process.cwd(), fullpath);
+            logger.info(`Adding file: “${realPath}” as “${relativePath}”`);
+            form.append('files', createReadStream(fullpath), {
+                filename: encodeURIComponent(relativePath),
+            });
+            gatheredData.files = [...(gatheredData.files || []), relativePath];
+        }, { recursive: true });
+    }
+    return [form, gatheredData];
+}
+export async function publishProject(buildConfig, url, ignoreConflict) {
+    logger.info(`Publishing ${buildConfig.name}@${buildConfig.version}…`);
+    const [form] = await makeProjectPayload(buildConfig);
+    try {
+        await axios.post(url, form);
+        logger.info(`Successfully published ${buildConfig.name}@${buildConfig.version} 🎉`);
+    }
+    catch (err) {
+        if (ignoreConflict && axios.isAxiosError(err) && err.response.status === 409) {
+            logger.warn(`${buildConfig.name}@${buildConfig.version} was already published.`);
+            return;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=project.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/cli",
-  "version": "0.23.4",
+  "version": "0.23.6",
   "description": "The CLI for developing with Appsemble apps and blocks",
   "keywords": [
     "app",
@@ -42,9 +42,9 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/node-utils": "0.23.4",
-    "@appsemble/types": "0.23.4",
-    "@appsemble/utils": "0.23.4",
+    "@appsemble/node-utils": "0.23.6",
+    "@appsemble/types": "0.23.6",
+    "@appsemble/utils": "0.23.6",
     "@fortawesome/fontawesome-common-types": "^6.0.0",
     "@koa/cors": "^4.0.0",
     "@odata/parser": "^0.2.0",
@@ -53,6 +53,7 @@
     "comment-parser": "^1.0.0",
     "cosmiconfig": "^7.0.0",
     "csvtojson": "^2.0.0",
+    "esbuild": "^0.19.0",
     "fast-glob": "^3.0.0",
     "form-data": "^4.0.0",
     "global-cache-dir": "^6.0.0",
@@ -85,7 +86,7 @@
     "yargs": "^17.0.0"
   },
   "devDependencies": {
-    "@appsemble/types": "0.23.4",
+    "@appsemble/types": "0.23.6",
     "@types/concat-stream": "^2.0.0",
     "@types/inquirer": "^9.0.0",
     "@types/normalize-path": "^3.0.0",