@hubspot/ui-extensions-dev-server 0.10.2 → 1.0.0

package/dist/lib/dev.js

@@ -1,75 +1,58 @@
-"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.startDevMode = startDevMode;
-const vite_1 = require("vite");
-const path_1 = __importDefault(require("path"));
-const server_1 = __importDefault(require("./server"));
-const devBuildPlugin_1 = __importDefault(require("./plugins/devBuildPlugin"));
-// @ts-expect-error no type defs
-const detect_port_1 = __importDefault(require("detect-port"));
-function _createViteDevServer(devServerState) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield (0, vite_1.createServer)({
-            root: devServerState.appPath,
-            logLevel: 'silent',
-            appType: 'custom',
-            mode: 'development',
-            server: {
-                middlewareMode: true,
-                hmr: {
-                    port: devServerState.webSocketPort,
-                },
-                watch: {
-                    ignored: [
-                        path_1.default.join(devServerState.outputDir, '/**/*'),
-                        '**/src/app/app.functions/**/*',
-                        '**/app.json',
-                        '**/package.json',
-                        '**/package-lock.json',
-                    ],
-                },
+import { createServer } from 'vite';
+import path from 'path';
+import startDevServer from "./server.js";
+import devBuildPlugin from "./plugins/devBuildPlugin.js";
+import { ALLOWED_ORIGIN_PATTERNS } from "./ExtensionsWebSocket.js";
+import detect from 'detect-port';
+async function _createViteDevServer(devServerState) {
+    return await createServer({
+        root: devServerState.appPath,
+        logLevel: 'silent',
+        appType: 'custom',
+        mode: 'development',
+        server: {
+            middlewareMode: true,
+            hmr: {
+                server: null, // We use our own WebSocket server (ExtensionsWebSocket) instead of Vite's
+            },
+            cors: {
+                origin: ALLOWED_ORIGIN_PATTERNS,
+                credentials: true,
             },
-            plugins: [
-                (0, devBuildPlugin_1.default)({
-                    devServerState,
-                }),
-            ],
-            clearScreen: false,
-        });
+            watch: {
+                ignored: [
+                    path.join(devServerState.outputDir, '/**/*'),
+                    '**/src/app/app.functions/**/*',
+                    '**/app.json',
+                    '**/package.json',
+                    '**/package-lock.json',
+                ],
+            },
+        },
+        plugins: [
+            devBuildPlugin({
+                devServerState,
+            }),
+        ],
+        clearScreen: false,
     });
 }
-function throwIfPortTaken(port) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // detect takes a port and returns the next available port
-        // so a mismatch means the requested port was not available
-        if ((yield (0, detect_port_1.default)(port)) !== port) {
-            throw new Error(`Unable to start because port ${port} is already in use`);
-        }
-    });
+async function throwIfPortTaken(port) {
+    // detect takes a port and returns the next available port
+    // so a mismatch means the requested port was not available
+    if ((await detect(port)) !== port) {
+        throw new Error(`Unable to start because port ${port} is already in use`);
+    }
 }
-function startDevMode(devServerState) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!devServerState || !devServerState.extensionsMetadata) {
-            throw new Error('Unable to determine which extension to run');
-        }
-        yield throwIfPortTaken(devServerState.webSocketPort);
-        const viteDevServer = yield _createViteDevServer(devServerState);
-        const shutdownServer = yield (0, server_1.default)({
-            devServerState,
-            viteDevServer,
-        });
-        return shutdownServer;
+export async function startDevMode(devServerState) {
+    if (!devServerState || !devServerState.extensionsMetadata) {
+        throw new Error('Unable to determine which extension to run');
+    }
+    await throwIfPortTaken(devServerState.expressPort);
+    const viteDevServer = await _createViteDevServer(devServerState);
+    const { shutdown } = await startDevServer({
+        devServerState,
+        viteDevServer,
     });
+    return shutdown;
 }

package/dist/lib/extensionsService.d.ts

@@ -1,4 +1,4 @@
-import { DevServerState } from './DevServerState';
+import { DevServerState } from './DevServerState.ts';
 import { Request, Response, Application } from 'express';
 declare class ExtensionsService {
     endpoint: string;

package/dist/lib/extensionsService.js

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable hubspot-dev/no-unsupported-ts-syntax */
-const path_1 = __importDefault(require("path"));
-const constants_1 = require("./constants");
-const utils_1 = require("./utils");
+import path from 'path';
+import { EXTENSIONS_MESSAGE_VERSION } from "./constants.js";
+import { loadManifest } from "./utils.js";
 class ExtensionsService {
+    endpoint;
     constructor() {
         this.endpoint = '/extensions';
     }
@@ -20,15 +15,26 @@ class ExtensionsService {
             try {
                 const extensions = devServerState.extensionsMetadata.map((metadata) => {
                     const { baseMessage } = metadata;
-                    const output = path_1.default.parse(baseMessage.callback).name;
-                    return Object.assign(Object.assign({}, baseMessage), { manifest: (0, utils_1.loadManifest)(devServerState.outputDir, output) });
+                    const output = path.parse(baseMessage.callback).name;
+                    return {
+                        ...baseMessage,
+                        manifest: loadManifest(devServerState.outputDir, output),
+                    };
                 });
-                const response = Object.assign({ websocket: `ws://localhost:${devServerState.webSocketPort}`, version: constants_1.EXTENSIONS_MESSAGE_VERSION, capabilities, portalId: devServerState.portalId, extensions }, (devServerState.functionsConfig.platformVersion && {
-                    platformVersion: devServerState.functionsConfig.platformVersion,
-                }));
+                const response = {
+                    websocket: `ws://localhost:${devServerState.expressPort}`,
+                    version: EXTENSIONS_MESSAGE_VERSION,
+                    capabilities,
+                    portalId: devServerState.portalId,
+                    extensions,
+                    ...(devServerState.functionsConfig.platformVersion && {
+                        platformVersion: devServerState.functionsConfig.platformVersion,
+                    }),
+                };
                 res.status(200).json(response);
             }
             catch (e) {
+                devServerState.logger.error(`Error in /extensions endpoint: ${e}`);
                 res.status(500).json({
                     message: 'Unable to determine which extensions are running',
                 });
@@ -36,4 +42,4 @@ class ExtensionsService {
         };
     }
 }
-exports.default = new ExtensionsService();
+export default new ExtensionsService();

package/dist/lib/parsing-utils.d.ts

@@ -1,5 +1,5 @@
 import { Node } from 'estree';
-import { NodeValue, SourceCodeMetadata } from './types';
+import { NodeValue, SourceCodeMetadata } from './types.ts';
 /**
  * Extracts the value from a given AST node based on its type.
  * This function handles various node types such as Literal, Identifier (aka variables), ArrayExpression,

package/dist/lib/parsing-utils.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueFromNode = getValueFromNode;
-exports.isVariableImported = isVariableImported;
-exports.isIdentifierDefined = isIdentifierDefined;
-exports.isFunctionInvoked = isFunctionInvoked;
 /**
  * Extracts the value from a given AST node based on its type.
  * This function handles various node types such as Literal, Identifier (aka variables), ArrayExpression,
@@ -25,7 +19,7 @@ exports.isFunctionInvoked = isFunctionInvoked;
  *          If the status is 'SUCCESS', nodeValue will contain the extracted value.
  *          If the status is 'FAIL', error will contain the error message.
  */
-function getValueFromNode(node, state) {
+export function getValueFromNode(node, state) {
     try {
         switch (node.type) {
             case 'Literal':
@@ -268,24 +262,26 @@ function getValueFromNode(node, state) {
         };
     }
 }
-function isVariableImported(node, variableName) {
+export function isVariableImported(node, variableName) {
     if (!node) {
         return false;
     }
-    return ((node.type === 'ImportSpecifier' && node.imported.name === variableName) ||
+    return ((node.type === 'ImportSpecifier' &&
+        node.imported.type === 'Identifier' &&
+        node.imported.name === variableName) ||
         (node.type === 'ImportDefaultSpecifier' &&
             node.local.name === variableName) ||
         (node.type === 'ImportNamespaceSpecifier' &&
             node.local.name === variableName));
 }
-function isIdentifierDefined(node, parent, name) {
+export function isIdentifierDefined(node, parent, name) {
     if (parent &&
         (parent.type === 'MemberExpression' || parent.type === 'CallExpression')) {
         return false;
     }
     return node.type === 'Identifier' && node.name === name;
 }
-function isFunctionInvoked(node, functionName) {
+export function isFunctionInvoked(node, functionName) {
     return (node.type === 'CallExpression' &&
         node.callee &&
         'name' in node.callee &&

package/dist/lib/plugins/codeBlockingPlugin.d.ts

@@ -1,5 +1,5 @@
 import { Rollup } from 'vite';
-import { Logger } from '../types';
+import { Logger } from '../types.ts';
 export type CodeBlockingPlugin = ({ logger, extensionPath, }: {
     logger: Logger;
     extensionPath: string;

package/dist/lib/plugins/codeBlockingPlugin.js

@@ -1,14 +1,11 @@
-"use strict";
-/* eslint-disable hubspot-dev/no-unsupported-ts-syntax */
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-const ast_1 = require("../ast");
+import { isNodeModule } from "../utils.js";
+import { traverseAbstractSyntaxTree } from "../ast.js";
 const codeBlockingPlugin = ({ logger, extensionPath }) => {
     return {
         name: 'ui-extensions-code-blocking-plugin',
         enforce: 'post', // run after default rollup plugins
         transform(code, filename) {
-            if ((0, utils_1.isNodeModule)(filename)) {
+            if (isNodeModule(filename)) {
                 return { code, map: null }; // We don't want to parse node modules
             }
             let sourceCodeMetadata = {
@@ -26,7 +23,7 @@ const codeBlockingPlugin = ({ logger, extensionPath }) => {
                 // the docs over on rollup's site specify ESTree.Program as the return type,
                 // and the underlying data matches that https://rollupjs.org/plugin-development/#this-parse
                 const abstractSyntaxTree = this.parse(code);
-                sourceCodeMetadata = (0, ast_1.traverseAbstractSyntaxTree)(abstractSyntaxTree, [{ functionName: requireFunctionName }], extensionPath, logger);
+                sourceCodeMetadata = traverseAbstractSyntaxTree(abstractSyntaxTree, [{ functionName: requireFunctionName }], extensionPath, logger);
                 if (sourceCodeMetadata.badImports) {
                     for (const badImport of sourceCodeMetadata.badImports) {
                         logger.warn(`Importing files from outside of the extension directory is not supported. Please move the import ${badImport} into the extension directory.`);
@@ -45,4 +42,4 @@ const codeBlockingPlugin = ({ logger, extensionPath }) => {
         },
     };
 };
-exports.default = codeBlockingPlugin;
+export default codeBlockingPlugin;

package/dist/lib/plugins/codeCheckingPlugin.d.ts

@@ -1,5 +1,5 @@
 import { Rollup } from 'vite';
-import { Logger } from '../types';
+import { Logger } from '../types.ts';
 export interface CodeCheckingPluginOptions {
     output: string;
     logger: Logger;

package/dist/lib/plugins/codeCheckingPlugin.js

@@ -1,17 +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 fs_1 = __importDefault(require("fs"));
+import fs from 'fs';
 const codeCheckingPlugin = (options) => {
     const { output, logger } = options;
     return {
         name: 'ui-extensions-code-checking-plugin',
         enforce: 'post',
-        writeBundle(__options, __bundle) {
+        writeBundle() {
             try {
-                const code = fs_1.default.readFileSync(output).toString();
+                const code = fs.readFileSync(output).toString();
                 if (!code.includes('const extend = (...args) => self.extend(...args);') &&
                     !code.includes('self.extend_V2(renderExtensionCallback)')) {
                     logger.warn('Unable to determine if your extension entry point is calling hubspot.extend, this may prevent it from rendering as expected');
@@ -23,4 +18,4 @@ const codeCheckingPlugin = (options) => {
         },
     };
 };
-exports.default = codeCheckingPlugin;
+export default codeCheckingPlugin;

package/dist/lib/plugins/devBuildPlugin.d.ts

@@ -1,5 +1,5 @@
-import Vite from 'vite';
-import { DevServerState } from '../DevServerState';
+import * as Vite from 'vite';
+import { DevServerState } from '../DevServerState.ts';
 export interface DevBuildPluginOptions {
     devServerState: DevServerState;
 }

package/dist/lib/plugins/devBuildPlugin.js

@@ -1,63 +1,17 @@
-"use strict";
-/* hs-eslint ignored failing-rules */
-/* eslint-disable hubspot-dev/no-unsupported-ts-syntax */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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 constants_1 = require("../constants");
-const vite_1 = require("vite");
-const manifestPlugin_1 = __importDefault(require("./manifestPlugin"));
-const utils_1 = require("../utils");
-const codeCheckingPlugin_1 = __importDefault(require("./codeCheckingPlugin"));
-const path_1 = __importDefault(require("path"));
-const friendlyLoggingPlugin_1 = __importDefault(require("./friendlyLoggingPlugin"));
-const relevantModulesPlugin_1 = __importStar(require("./relevantModulesPlugin"));
-const codeBlockingPlugin_1 = __importDefault(require("./codeBlockingPlugin"));
+import { ROLLUP_OPTIONS, WEBSOCKET_MESSAGE_VERSION } from "../constants.js";
+import { build } from 'vite';
+import manifestPlugin from "./manifestPlugin.js";
+import { stripAnsiColorCodes } from "../utils.js";
+import codeCheckingPlugin from "./codeCheckingPlugin.js";
+import path from 'path';
+import friendlyLoggingPlugin from "./friendlyLoggingPlugin.js";
+import relevantModulesPlugin, { getRelevantModules, } from "./relevantModulesPlugin.js";
+import codeBlockingPlugin from "./codeBlockingPlugin.js";
 function addVersionToBaseMessage(baseMessage) {
-    return Object.assign(Object.assign({}, baseMessage), { version: constants_1.WEBSOCKET_MESSAGE_VERSION });
+    return {
+        ...baseMessage,
+        version: WEBSOCKET_MESSAGE_VERSION,
+    };
 }
 function isValidVariablesRecord(obj) {
     if (!obj || typeof obj !== 'object')
@@ -71,22 +25,25 @@ const devBuildPlugin = (options) => {
     const { devServerState } = options;
     const { logger } = devServerState;
     let lastBuildErrorContext;
-    const handleBuildError = (error, server) => {
+    const handleBuildError = (error) => {
         const { error: { plugin, errors, frame, loc, id }, extensionMetadata, } = error;
         // Filter out our custom plugins, but send everything else
-        if (!(plugin === null || plugin === void 0 ? void 0 : plugin.startsWith('ui-extensions'))) {
-            // @ts-expect-error Our websocket messages don't match Vite format
-            server.ws.send(Object.assign(Object.assign({}, addVersionToBaseMessage(extensionMetadata.baseMessage)), { event: 'error', error: {
+        if (!plugin?.startsWith('ui-extensions')) {
+            devServerState.getExtensionsWebSocket().broadcast({
+                ...addVersionToBaseMessage(extensionMetadata.baseMessage),
+                event: 'error',
+                error: {
                     details: {
                         errors,
-                        formattedError: (0, utils_1.stripAnsiColorCodes)(frame),
+                        formattedError: stripAnsiColorCodes(frame),
                         location: loc,
                         file: id,
                     },
-                } }));
+                },
+            });
         }
     };
-    const devBuild = (server_1, extensionMetadata_1, ...args_1) => __awaiter(void 0, [server_1, extensionMetadata_1, ...args_1], void 0, function* (server, extensionMetadata, emptyOutDir = false) {
+    const devBuild = async (server, extensionMetadata, emptyOutDir = false) => {
         try {
             const { config: extensionConfig } = extensionMetadata;
             const { extensionPath } = extensionConfig;
@@ -98,7 +55,7 @@ const devBuildPlugin = (options) => {
                     variables: devServerState.appConfig.variables,
                 };
             }
-            yield (0, vite_1.build)({
+            await build({
                 logLevel: 'warn',
                 mode: 'development',
                 define: {
@@ -118,28 +75,35 @@ const devBuildPlugin = (options) => {
                         formats: ['iife'],
                         fileName: () => extensionConfig.output,
                     },
-                    rollupOptions: Object.assign(Object.assign({}, constants_1.ROLLUP_OPTIONS), { plugins: [
-                            (0, manifestPlugin_1.default)({
+                    rollupOptions: {
+                        ...ROLLUP_OPTIONS,
+                        plugins: [
+                            manifestPlugin({
                                 minify: false,
                                 output: extensionConfig.output,
                                 extensionPath,
                                 logger,
                                 manifestConfig,
                             }),
-                            (0, codeCheckingPlugin_1.default)({
-                                output: path_1.default.join(devServerState.outputDir, extensionConfig.output),
+                            codeCheckingPlugin({
+                                output: path.join(devServerState.outputDir, extensionConfig.output),
                                 logger,
                             }),
-                            (0, friendlyLoggingPlugin_1.default)({ logger }),
-                            (0, relevantModulesPlugin_1.default)({
+                            friendlyLoggingPlugin({ logger }),
+                            relevantModulesPlugin({
                                 output: extensionConfig.output,
                                 logger,
                             }),
-                            (0, codeBlockingPlugin_1.default)({ logger, extensionPath }),
-                        ], output: Object.assign(Object.assign({}, constants_1.ROLLUP_OPTIONS.output), { sourcemap: 'inline' }) }),
+                            codeBlockingPlugin({ logger, extensionPath }),
+                        ],
+                        output: {
+                            ...ROLLUP_OPTIONS.output,
+                        },
+                    },
                     outDir: devServerState.outputDir,
                     emptyOutDir,
                     minify: false,
+                    sourcemap: 'inline',
                 },
                 clearScreen: false,
             });
@@ -152,68 +116,79 @@ const devBuildPlugin = (options) => {
                 extensionMetadata,
             };
             logger.debug(error);
-            handleBuildError(lastBuildErrorContext, server);
+            handleBuildError(lastBuildErrorContext);
             return false;
         }
-    });
+    };
     let localServer;
     return {
         name: 'ui-extensions-dev-build-plugin',
         enforce: 'pre',
-        configureServer: (server) => __awaiter(void 0, void 0, void 0, function* () {
+        configureServer: async (server) => {
             // Store a reference to the server to be used in hooks that don't get the server injected
             // See https://vitejs.dev/guide/api-plugin.html#configureserver for information on this pattern
             localServer = server;
-            localServer.ws.on('connection', () => {
-                logger.info('Browser connected and listening for bundle updates');
-                devServerState.extensionsMetadata.forEach((metadata) => {
-                    // @ts-expect-error Our websocket messages don't match Vite format
-                    localServer.ws.send(Object.assign(Object.assign({}, addVersionToBaseMessage(metadata.baseMessage)), { event: 'start' }));
+            // Store the WebSocket setup to be called after the WebSocket is initialized
+            devServerState.setWebSocketSetupCallback(() => {
+                devServerState.getExtensionsWebSocket().onConnection(() => {
+                    logger.info('Browser connected and listening for bundle updates');
+                    devServerState.extensionsMetadata.forEach((metadata) => {
+                        devServerState.getExtensionsWebSocket().broadcast({
+                            ...addVersionToBaseMessage(metadata.baseMessage),
+                            event: 'start',
+                        });
+                    });
+                    if (lastBuildErrorContext) {
+                        handleBuildError(lastBuildErrorContext);
+                    }
                 });
-                if (lastBuildErrorContext) {
-                    handleBuildError(lastBuildErrorContext, server);
-                }
             });
             for (let i = 0; i < devServerState.extensionsMetadata.length; ++i) {
-                yield devBuild(localServer, devServerState.extensionsMetadata[i], i === 0);
+                await devBuild(localServer, devServerState.extensionsMetadata[i], i === 0);
             }
-        }),
-        handleHotUpdate: (_a) => __awaiter(void 0, [_a], void 0, function* ({ file, server }) {
+        },
+        handleHotUpdate: async ({ file, server }) => {
             // If the file is not in the relevantModules list, it's update is inconsequential
             const extensionsToRebuild = devServerState.extensionsMetadata.filter((metadata) => {
                 const { config } = metadata;
-                return (0, relevantModulesPlugin_1.getRelevantModules)(config.output).includes(file);
+                return getRelevantModules(config.output).includes(file);
             });
             for (let i = 0; i < extensionsToRebuild.length; ++i) {
                 const toRebuild = extensionsToRebuild[i];
-                const successful = yield devBuild(server, toRebuild);
+                const successful = await devBuild(server, toRebuild);
                 if (!successful) {
                     return [];
                 }
                 const { config: extensionConfig } = toRebuild;
                 logger.info(`Extension ${extensionConfig.data.title} updated, compiled`);
-                if (server.ws.clients.size === 0) {
+                const ws = devServerState.getExtensionsWebSocket();
+                if (ws.clientCount === 0) {
                     logger.debug('Bundle updated, no browsers connected to notify');
                     return [];
                 }
                 logger.debug('Bundle updated, notifying connected browsers');
-                // @ts-expect-error Our websocket messages don't match Vite format
-                server.ws.send(Object.assign(Object.assign({}, addVersionToBaseMessage(toRebuild.baseMessage)), { event: 'update' }));
+                ws.broadcast({
+                    ...addVersionToBaseMessage(toRebuild.baseMessage),
+                    event: 'update',
+                });
             }
             return [];
-        }),
+        },
         buildEnd(error) {
             if (error) {
                 logger.error(error);
             }
-            if (localServer && localServer.ws) {
+            const ws = devServerState.extensionsWebSocket;
+            if (ws) {
                 logger.debug('Sending shutdown message to connected browsers');
                 devServerState.extensionsMetadata.forEach((metadata) => {
-                    // @ts-expect-error Our websocket messages don't match Vite format
-                    localServer.ws.send(Object.assign(Object.assign({}, addVersionToBaseMessage(metadata.baseMessage)), { event: 'shutdown' }));
+                    ws.broadcast({
+                        ...addVersionToBaseMessage(metadata.baseMessage),
+                        event: 'shutdown',
+                    });
                 });
             }
         },
     };
 };
-exports.default = devBuildPlugin;
+export default devBuildPlugin;

package/dist/lib/plugins/friendlyLoggingPlugin.d.ts

@@ -1,6 +1,6 @@
 import { RollupLog, LogLevel } from 'rollup';
-import Vite from 'vite';
-import { Logger } from '../types';
+import * as Vite from 'vite';
+import { Logger } from '../types.ts';
 export interface MappedLog {
     message?: string;
     level?: 'error' | LogLevel;

package/dist/lib/plugins/friendlyLoggingPlugin.js

@@ -1,15 +1,8 @@
-"use strict";
-/* hs-eslint ignored failing-rules */
-/* eslint-disable hubspot-dev/no-unsupported-ts-syntax */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
+import path from 'path';
 const unfriendlyCodeMapper = Object.freeze({
     UNRESOLVED_IMPORT: (loggable) => {
         const { exporter, id } = loggable;
-        const { base: extension } = path_1.default.parse(id);
+        const { base: extension } = path.parse(id);
         return {
             message: `${exporter} is imported by ${extension}, but ${exporter} cannot be resolved. Make sure ${exporter} is installed.`,
             level: 'error',
@@ -37,8 +30,7 @@ function friendlyLoggingPlugin({ logger }) {
     };
 }
 function _mapMessageToFriendlyVersion(loggable) {
-    var _a, _b;
     const { code } = loggable;
-    return (_b = (_a = unfriendlyCodeMapper[code]) === null || _a === void 0 ? void 0 : _a.call(unfriendlyCodeMapper, loggable)) !== null && _b !== void 0 ? _b : {};
+    return unfriendlyCodeMapper[code]?.(loggable) ?? {};
 }
-exports.default = friendlyLoggingPlugin;
+export default friendlyLoggingPlugin;