@hubspot/ui-extensions-dev-server 0.7.3 → 0.8.0

package/dist/cli/config.d.ts

@@ -0,0 +1,9 @@
+import { AppConfig, ExtensionConfigMap } from '../lib/types';
+declare function loadConfigByPath(configPath: string): any;
+declare function loadExtensionConfig(appConfig: AppConfig, appPath: string): ExtensionConfigMap;
+/**
+ * @deprecated Will be removed after integration with hubspot-cli is complete
+ * This version of load config makes assumptions about the location it is being ran from where the others do not
+ */
+declare function loadConfig(): ExtensionConfigMap;
+export { loadConfigByPath, loadExtensionConfig, loadConfig };

package/dist/cli/config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = exports.loadExtensionConfig = exports.loadConfigByPath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../lib/utils");
+const constants_1 = require("../lib/constants");
+function loadConfigByPath(configPath) {
+    const source = fs_1.default.readFileSync(configPath).toString();
+    return JSON.parse(source);
+}
+exports.loadConfigByPath = loadConfigByPath;
+function loadExtensionConfig(appConfig, appPath) {
+    var _a, _b;
+    const crmCardsSubConfigFiles = (_b = (_a = appConfig === null || appConfig === void 0 ? void 0 : appConfig.extensions) === null || _a === void 0 ? void 0 : _a.crm) === null || _b === void 0 ? void 0 : _b.cards;
+    const outputConfig = {};
+    crmCardsSubConfigFiles.forEach(card => {
+        var _a, _b;
+        const cardConfigPath = path_1.default.join(appPath, card.file);
+        try {
+            const cardConfig = loadConfigByPath(cardConfigPath);
+            if (cardConfig && cardConfig.data) {
+                const cardConfigDir = path_1.default.parse(cardConfigPath).dir;
+                const entryPointPath = path_1.default.join(cardConfigDir, (_b = (_a = cardConfig.data) === null || _a === void 0 ? void 0 : _a.module) === null || _b === void 0 ? void 0 : _b.file);
+                cardConfig.data.module.file = entryPointPath;
+                outputConfig[entryPointPath] = Object.assign(Object.assign({}, cardConfig), { output: (0, utils_1.getUrlSafeFileName)(entryPointPath), path: appPath, extensionPath: path_1.default.parse(entryPointPath).dir, data: Object.assign(Object.assign({}, cardConfig.data), { appName: appConfig.name }) });
+            }
+        }
+        catch (e) {
+            throw new Error(`Unable to load ${cardConfigPath}`);
+        }
+    });
+    return outputConfig;
+}
+exports.loadExtensionConfig = loadExtensionConfig;
+/**
+ * @deprecated Will be removed after integration with hubspot-cli is complete
+ * This version of load config makes assumptions about the location it is being ran from where the others do not
+ */
+function loadConfig() {
+    var _a, _b;
+    // app.json is one level up from the extensions directory, which is where these commands
+    // will need to be ran from, the extensions directory
+    const configPath = path_1.default.join(process.cwd(), '..', constants_1.MAIN_APP_CONFIG);
+    const mainAppConfig = loadConfigByPath(configPath);
+    const crmCardsSubConfigFiles = (_b = (_a = mainAppConfig === null || mainAppConfig === void 0 ? void 0 : mainAppConfig.extensions) === null || _a === void 0 ? void 0 : _a.crm) === null || _b === void 0 ? void 0 : _b.cards;
+    if (!crmCardsSubConfigFiles || crmCardsSubConfigFiles.length === 0) {
+        throw new Error(`The "extensions.crm.cards" array in ${configPath} is missing or empty, it is a required configuration property`);
+    }
+    const outputConfig = {};
+    crmCardsSubConfigFiles.forEach(card => {
+        const cardConfigPath = path_1.default.join(process.cwd(), '..', card.file);
+        try {
+            const cardConfig = loadConfigByPath(cardConfigPath);
+            if (!cardConfig.data) {
+                throw new Error(`Invalid config file at path ${cardConfigPath}, data is a required config property`);
+            }
+            if (!cardConfig.data.module) {
+                throw new Error(`Invalid config file at path ${cardConfigPath}, data.module is a require property`);
+            }
+            // Path.join with a single argument will strip off any relative prefixing such as './'
+            const entryPointPath = path_1.default.join(cardConfig.data.module.file);
+            cardConfig.data.module.file = entryPointPath;
+            outputConfig[entryPointPath] = cardConfig;
+            outputConfig[entryPointPath].data.appName = mainAppConfig.name;
+        }
+        catch (e) {
+            if ((e === null || e === void 0 ? void 0 : e.code) === 'MODULE_NOT_FOUND') {
+                throw new Error(`Unable to load "${cardConfigPath}" file. \nPlease make sure you are running the command from the src/app/extensions directory and that your card JSON config exists within it.`);
+            }
+            throw e;
+        }
+    });
+    return outputConfig;
+}
+exports.loadConfig = loadConfig;

package/dist/cli/run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/run.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../cli/utils");
+const index_1 = require("../index");
+const console_log_colors_1 = require("console-log-colors");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../lib/constants");
+const inquirer_1 = __importDefault(require("inquirer"));
+const config_1 = require("./config");
+// eslint-disable-next-line no-floating-promise/no-floating-promise
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const { DEV_MODE, BUILD_MODE, extension, help, force } = (0, utils_1.parseArgs)();
+    if (!force) {
+        console.warn((0, console_log_colors_1.yellow)(`"hs-ui-extensions-dev-server" is deprecated, please use "hs project dev" for local development.
+        \nSee our Getting Started guide for detailed instructions: https://app.hubspot.com/l/docs/doc/platform/create-a-project-for-ui-extensions\n`));
+        process.exit(0);
+    }
+    if (help || !(DEV_MODE || BUILD_MODE)) {
+        (0, utils_1.showHelp)(constants_1.OUTPUT_DIR);
+    }
+    else if (DEV_MODE) {
+        const extensionPath = process.cwd(); // Assumed to be /path/to/src/app/extensions
+        const appPath = path_1.default.join(extensionPath, '..');
+        const appConfig = (0, config_1.loadConfigByPath)(path_1.default.join(appPath, constants_1.MAIN_APP_CONFIG));
+        let extensionConfig;
+        if (extension) {
+            const allExtensionsConfig = (0, config_1.loadExtensionConfig)(appConfig, appPath);
+            extensionConfig =
+                allExtensionsConfig[path_1.default.join(extensionPath, extension)];
+        }
+        yield index_1.DevModeInterface.setup({
+            promptUser: inquirer_1.default.createPromptModule(),
+            components: {
+                [appConfig.name]: {
+                    config: appConfig,
+                    path: path_1.default.join(extensionPath, '..'),
+                },
+            },
+            extensionConfig,
+        });
+        yield index_1.DevModeInterface.start({});
+    }
+    else if (BUILD_MODE) {
+        if (extension) {
+            (0, index_1.buildSingleExtension)({
+                file: extension,
+                outputDir: constants_1.OUTPUT_DIR,
+            });
+        }
+        else {
+            (0, index_1.buildAllExtensions)({ outputDir: constants_1.OUTPUT_DIR });
+        }
+    }
+}))();
+function shutdown() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield index_1.DevModeInterface.cleanup();
+        process.exit(0);
+    });
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/dist/cli/utils.d.ts

@@ -0,0 +1,3 @@
+declare function parseArgs(): any;
+declare function showHelp(OUTPUT_DIR: string): void;
+export { parseArgs, showHelp };

package/dist/cli/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHelp = exports.parseArgs = void 0;
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+// @ts-expect-error no type defs
+const command_line_args_1 = __importDefault(require("command-line-args"));
+// @ts-expect-error no type defs
+const command_line_usage_1 = __importDefault(require("command-line-usage"));
+function parseArgs() {
+    const mainDefinitions = [{ name: 'command', defaultOption: true }];
+    const mainOptions = (0, command_line_args_1.default)(mainDefinitions, {
+        stopAtFirstUnknown: true,
+    });
+    const argv = mainOptions._unknown || [];
+    const DEV_MODE = mainOptions.command === 'dev';
+    const BUILD_MODE = mainOptions.command === 'build';
+    const optionDefinitions = [
+        { name: 'port', alias: 'p', type: Number },
+        { name: 'extension', alias: 'e', type: String },
+        { name: 'help', alias: 'h', type: Boolean },
+        { name: 'force', alias: 'f', type: Boolean },
+    ];
+    const options = (0, command_line_args_1.default)(optionDefinitions, DEV_MODE || BUILD_MODE ? { argv } : {});
+    return Object.assign({ DEV_MODE, BUILD_MODE }, options);
+}
+exports.parseArgs = parseArgs;
+function showHelp(OUTPUT_DIR) {
+    const sections = [
+        {
+            header: 'HubSpot UI Extensions Local Dev Server',
+            content: `Used for local development of HubSpot extensions.  Built assets can be found in the ${OUTPUT_DIR} directory`,
+        },
+        {
+            header: 'Available Commands',
+            content: [
+                { name: 'dev', summary: 'starts the local development server' },
+                { name: 'build', summary: 'runs a build of your extensions' },
+            ],
+        },
+        {
+            header: 'Options',
+            optionList: [
+                {
+                    name: 'extension',
+                    alias: 'e',
+                    typeLabel: '{underline file}',
+                    description: 'The extension entrypoint file to build or start local development for',
+                },
+                {
+                    name: 'help',
+                    alias: 'h',
+                    description: 'Print this usage guide.',
+                },
+            ],
+        },
+    ];
+    const usage = (0, command_line_usage_1.default)(sections);
+    logger_1.logger.info(usage);
+    process.exit(0);
+}
+exports.showHelp = showHelp;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { remoteBuild, buildAllExtensions, buildSingleExtension } from './lib/build';
+import DevModeInterface from './lib/DevModeInterface';
+export { remoteBuild, buildAllExtensions, buildSingleExtension, DevModeInterface, };

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck We aren't ready to type check these files yet
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevModeInterface = exports.buildSingleExtension = exports.buildAllExtensions = exports.remoteBuild = void 0;
+const build_1 = require("./lib/build");
+Object.defineProperty(exports, "remoteBuild", { enumerable: true, get: function () { return build_1.remoteBuild; } });
+Object.defineProperty(exports, "buildAllExtensions", { enumerable: true, get: function () { return build_1.buildAllExtensions; } });
+Object.defineProperty(exports, "buildSingleExtension", { enumerable: true, get: function () { return build_1.buildSingleExtension; } });
+const DevModeInterface_1 = __importDefault(require("./lib/DevModeInterface"));
+exports.DevModeInterface = DevModeInterface_1.default;

package/dist/lib/DevModeInterface.d.ts

@@ -0,0 +1,35 @@
+import { ExtensionConfig, ProjectComponentMap } from './types';
+import { ServiceConfiguration } from '@hubspot/app-functions-dev-server/dist/types';
+import { PromptModule } from 'inquirer';
+interface SetupArguments {
+    components: ProjectComponentMap;
+    debug?: boolean;
+    extensionConfig?: ExtensionConfig;
+    onUploadRequired?: VoidFunction;
+    promptUser: PromptModule;
+}
+interface StartArguments {
+    accountId?: number;
+    debug?: boolean;
+    httpClient?: ServiceConfiguration['httpClient'];
+}
+interface AppExtensionMapping {
+    name: string;
+    value: ExtensionConfig;
+}
+declare class DevModeInterface {
+    config?: ExtensionConfig;
+    appName?: string;
+    title?: string;
+    cardConfigs?: string[];
+    onUploadRequired?: VoidFunction;
+    shutdown?: () => Promise<void>;
+    _setDataFromExtensionConfig(extensionConfig: ExtensionConfig): void;
+    _generateAppExtensionMappings(components: ProjectComponentMap): AppExtensionMapping[];
+    setup({ components, debug, extensionConfig, onUploadRequired, promptUser, }: SetupArguments): Promise<void>;
+    fileChange(filePath: string, __event: unknown): Promise<void>;
+    start({ accountId, debug, httpClient }: StartArguments): Promise<void>;
+    cleanup(): Promise<void>;
+}
+declare const _default: DevModeInterface;
+export default _default;

package/dist/lib/DevModeInterface.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dev_1 = require("./dev");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const config_1 = require("../cli/config");
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+class DevModeInterface {
+    _setDataFromExtensionConfig(extensionConfig) {
+        this.config = extensionConfig;
+        this.appName = extensionConfig.data.appName;
+        this.title = extensionConfig.data.title;
+    }
+    _generateAppExtensionMappings(components) {
+        // Loop over all of the app configs that are passed in
+        const allComponentNames = Object.keys(components);
+        return allComponentNames.reduce((appExtensionMappings, componentName) => {
+            var _a, _b;
+            const component = components[componentName];
+            if (!((_b = (_a = component.config.extensions) === null || _a === void 0 ? void 0 : _a.crm) === null || _b === void 0 ? void 0 : _b.cards)) {
+                return appExtensionMappings; // It's not an app
+            }
+            this.cardConfigs = component.config.extensions.crm.cards.map(card => path_1.default.join(component.path, card.file));
+            // Load all of the extension configs for a particular app.json file
+            const extensionsConfigForApp = (0, config_1.loadExtensionConfig)(component.config, component.path);
+            const extensionFilePaths = Object.keys(extensionsConfigForApp);
+            // Loop over the loaded extension configs and generate the list of choices to use to prompt the user for input
+            extensionFilePaths.forEach(extensionPath => {
+                const extensionConfig = extensionsConfigForApp[extensionPath];
+                appExtensionMappings.push({
+                    name: `${componentName}/${extensionConfig.data.title}`,
+                    value: extensionConfig,
+                });
+            });
+            return appExtensionMappings;
+        }, []);
+    }
+    setup({ components, debug = false, extensionConfig, onUploadRequired, promptUser, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, logger_1.setLogLevel)(debug ? logger_1.LOG_LEVEL.DEBUG : logger_1.LOG_LEVEL.LOG);
+            this.onUploadRequired = onUploadRequired;
+            if (extensionConfig) {
+                this._setDataFromExtensionConfig(extensionConfig);
+                return;
+            }
+            const choices = this._generateAppExtensionMappings(components);
+            if (choices.length === 0) {
+                throw new Error('No extensions to run');
+            }
+            else if (choices.length === 1) {
+                this._setDataFromExtensionConfig(choices[0].value);
+            }
+            else {
+                const answers = yield promptUser({
+                    type: 'list',
+                    name: 'extension',
+                    message: 'Which extension would you like to run?',
+                    choices,
+                });
+                this._setDataFromExtensionConfig(answers.extension);
+            }
+        });
+    }
+    // The contract is for this to be async, so eslint can chill
+    // eslint-disable-next-line require-await
+    fileChange(filePath, __event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cardConfigs &&
+                this.cardConfigs.includes(filePath) &&
+                this.onUploadRequired) {
+                this.onUploadRequired();
+            }
+        });
+    }
+    start({ accountId, debug, httpClient }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (debug !== undefined) {
+                (0, logger_1.setLogLevel)(debug ? logger_1.LOG_LEVEL.DEBUG : logger_1.LOG_LEVEL.LOG);
+            }
+            if (!this.config || !this.config.path) {
+                throw new Error('Unable to load the required extension configuration files');
+            }
+            const appPath = this.config.path;
+            // Pass options from the CLI for running app functions locally
+            const functionsConfig = {
+                app: { path: appPath },
+                accountId,
+                httpClient,
+            };
+            this.shutdown = yield (0, dev_1.startDevMode)({
+                extensionConfig: this.config,
+                outputDir: path_1.default.join(this.config.extensionPath, constants_1.OUTPUT_DIR),
+                functionsConfig,
+                root: appPath,
+                cardConfigs: this.cardConfigs || [],
+            });
+            logger_1.logger.info(`Running extension '${this.title}' from app '${this.appName}'`);
+        });
+    }
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shutdown) {
+                yield this.shutdown();
+            }
+        });
+    }
+}
+exports.default = new DevModeInterface();

package/dist/lib/build.d.ts

@@ -0,0 +1,14 @@
+interface BuildSingleExtenstionArgs {
+    file: string;
+    outputDir?: string;
+    emptyOutDir?: boolean;
+    minify?: boolean;
+    root?: string;
+}
+declare const extensionErrorBaseMessage: string;
+declare function buildAllExtensions({ outputDir }: {
+    outputDir: string;
+}): Promise<void>;
+declare function buildSingleExtension({ file, outputDir, emptyOutDir, minify, root, }: BuildSingleExtenstionArgs): Promise<void>;
+declare function remoteBuild(root: string, entryPoint: string, outputDir?: string): Promise<void>;
+export { buildAllExtensions, buildSingleExtension, remoteBuild, extensionErrorBaseMessage, };

package/dist/lib/build.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionErrorBaseMessage = exports.remoteBuild = exports.buildSingleExtension = exports.buildAllExtensions = void 0;
+const vite_1 = require("vite");
+const constants_1 = require("./constants");
+const manifestPlugin_1 = __importDefault(require("./plugins/manifestPlugin"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const config_1 = require("../cli/config");
+const codeInjectionPlugin_1 = __importDefault(require("./plugins/codeInjectionPlugin"));
+const allowedExtensions = ['.js', '.ts', '.tsx', '.jsx'];
+const extensionErrorBaseMessage = `Supported file extensions are [${allowedExtensions.join(', ')}], received:`;
+exports.extensionErrorBaseMessage = extensionErrorBaseMessage;
+function buildAllExtensions({ outputDir }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = (0, config_1.loadConfig)();
+        const extensionKeys = Object.keys(config);
+        for (let i = 0; i < extensionKeys.length; ++i) {
+            const { data } = config[extensionKeys[i]];
+            yield buildSingleExtension({
+                file: data.module.file,
+                outputDir,
+                emptyOutDir: i === 0,
+            });
+        }
+    });
+}
+exports.buildAllExtensions = buildAllExtensions;
+function buildSingleExtension({ file, outputDir = constants_1.OUTPUT_DIR, emptyOutDir = true, minify = false, root = process.cwd(), // This is the vite default, so using that as our default
+ }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const output = (0, utils_1.getUrlSafeFileName)(file);
+        yield (0, vite_1.build)({
+            root,
+            define: {
+                'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'production'),
+            },
+            build: {
+                lib: {
+                    entry: file,
+                    name: output,
+                    formats: ['iife'],
+                    fileName: () => output,
+                },
+                rollupOptions: Object.assign(Object.assign({}, constants_1.ROLLUP_OPTIONS), { plugins: [(0, manifestPlugin_1.default)({ output }), (0, codeInjectionPlugin_1.default)({ file })] }),
+                outDir: outputDir,
+                emptyOutDir,
+                minify,
+            },
+        });
+    });
+}
+exports.buildSingleExtension = buildSingleExtension;
+function remoteBuild(root, entryPoint, outputDir = constants_1.OUTPUT_DIR) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileInfo = path_1.default.parse(entryPoint);
+        if (!allowedExtensions.includes(fileInfo.ext)) {
+            throw new Error(`${extensionErrorBaseMessage} ${fileInfo.ext}`);
+        }
+        yield buildSingleExtension({
+            file: entryPoint,
+            outputDir,
+            minify: true,
+            root,
+        });
+    });
+}
+exports.remoteBuild = remoteBuild;

package/dist/lib/constants.d.ts

@@ -0,0 +1,19 @@
+declare const OUTPUT_DIR = "dist";
+declare const MAIN_APP_CONFIG = "app.json";
+declare const MANIFEST_FILE = "manifest.json";
+declare const VITE_DEFAULT_PORT = 5173;
+declare const WEBSOCKET_PORT = 5174;
+declare const ROLLUP_OPTIONS: {
+    external: string[];
+    output: {
+        globals: {
+            react: string;
+            '@remote-ui/react': string;
+        };
+        extend: boolean;
+    };
+};
+declare const EXTENSIONS_MESSAGE_VERSION = 1;
+declare const WEBSOCKET_MESSAGE_VERSION = 0;
+declare const SERVER_CAPABILITIES: string[];
+export { ROLLUP_OPTIONS, OUTPUT_DIR, MAIN_APP_CONFIG, MANIFEST_FILE, EXTENSIONS_MESSAGE_VERSION, VITE_DEFAULT_PORT, WEBSOCKET_MESSAGE_VERSION, WEBSOCKET_PORT, SERVER_CAPABILITIES, };

package/dist/lib/constants.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_CAPABILITIES = exports.WEBSOCKET_PORT = exports.WEBSOCKET_MESSAGE_VERSION = exports.VITE_DEFAULT_PORT = exports.EXTENSIONS_MESSAGE_VERSION = exports.MANIFEST_FILE = exports.MAIN_APP_CONFIG = exports.OUTPUT_DIR = exports.ROLLUP_OPTIONS = void 0;
+const OUTPUT_DIR = 'dist';
+exports.OUTPUT_DIR = OUTPUT_DIR;
+const MAIN_APP_CONFIG = 'app.json';
+exports.MAIN_APP_CONFIG = MAIN_APP_CONFIG;
+const MANIFEST_FILE = 'manifest.json';
+exports.MANIFEST_FILE = MANIFEST_FILE;
+const VITE_DEFAULT_PORT = 5173;
+exports.VITE_DEFAULT_PORT = VITE_DEFAULT_PORT;
+const WEBSOCKET_PORT = 5174;
+exports.WEBSOCKET_PORT = WEBSOCKET_PORT;
+const ROLLUP_OPTIONS = {
+    // Deps to exclude from the bundle
+    external: ['react', 'react-dom', '@remote-ui/react'],
+    output: {
+        // Maps libs to the variables to be injected via the window
+        globals: {
+            react: 'React',
+            '@remote-ui/react': 'RemoteUI',
+        },
+        extend: true,
+    },
+};
+exports.ROLLUP_OPTIONS = ROLLUP_OPTIONS;
+const EXTENSIONS_MESSAGE_VERSION = 1;
+exports.EXTENSIONS_MESSAGE_VERSION = EXTENSIONS_MESSAGE_VERSION;
+const WEBSOCKET_MESSAGE_VERSION = 0;
+exports.WEBSOCKET_MESSAGE_VERSION = WEBSOCKET_MESSAGE_VERSION;
+const SERVER_CAPABILITIES = [
+    // Supports running app functions locally
+    'app-functions-local-dev',
+];
+exports.SERVER_CAPABILITIES = SERVER_CAPABILITIES;

package/dist/lib/dev.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionConfig } from './types';
+import { ServiceConfiguration } from '@hubspot/app-functions-dev-server/dist/types';
+interface StartDevModeArgs {
+    outputDir?: string;
+    extensionConfig: ExtensionConfig;
+    webSocketPort?: number;
+    expressPort?: number;
+    root?: string;
+    functionsConfig: Partial<ServiceConfiguration>;
+    cardConfigs: string[];
+}
+declare function startDevMode({ extensionConfig, functionsConfig, outputDir, expressPort, webSocketPort, root, cardConfigs, }: StartDevModeArgs): Promise<() => Promise<void>>;
+export { startDevMode };