@hubspot/ui-extensions-dev-server 0.9.3 → 0.9.5

package/dist/index.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevModeUnifiedInterfaceNonSingleton = exports.DevModeUnifiedInterface = exports.DevModeInterfaceNonSingleton = exports.DevModeInterface = exports.buildSingleExtension = exports.remoteBuild = void 0;
 const build_1 = require("./lib/build");

package/dist/lib/DevModeParentInterface.d.ts

@@ -12,7 +12,7 @@ export declare abstract class DevModeParentInterface {
     protected abstract _generateAppExtensionMappings(components: ProjectComponentMap | UnifiedProjectComponentMap): AppExtensionMapping[];
     _getPlatformVersion(projectConfig?: ProjectConfig): PlatformVersion;
     _reset(): void;
-    parentSetup({ onUploadRequired, promptUser, logger, urls, setActiveApp, choices, }: DevModeBaseSetupArguments): Promise<void>;
+    parentSetup({ onUploadRequired, logger, urls, setActiveApp, choices, }: DevModeBaseSetupArguments): Promise<void>;
     start({ requestPorts, accountId, projectConfig, }: DevModeStartArguments): Promise<void>;
     fileChange(filePath: string, __event: unknown): Promise<void>;
     cleanup(): Promise<void>;

package/dist/lib/DevModeParentInterface.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.DevModeParentInterface = void 0;
 const constants_1 = require("./constants");
@@ -16,6 +19,7 @@ const config_1 = require("./config");
 const constants_2 = require("./constants");
 const utils_1 = require("./utils");
 const DevServerState_1 = require("./DevServerState");
+const inquirer_1 = __importDefault(require("inquirer"));
 const defaultLogger = {
     info: (...args) => {
         console.log(...args);
@@ -63,9 +67,9 @@ class DevModeParentInterface {
         this.isConfigured = false;
         this.isRunning = false;
     }
-    parentSetup(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ onUploadRequired, promptUser, logger, urls, setActiveApp, choices = [], }) {
-            var _b, _c, _d;
+    parentSetup({ onUploadRequired, logger, urls, setActiveApp, choices = [], }) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
             if (this.isConfigured) {
                 logger.debug('Dev server has already been configured, skipping');
                 return;
@@ -80,7 +84,8 @@ class DevModeParentInterface {
                 this.configs = [choices[0].value];
             }
             else {
-                const answers = yield promptUser({
+                const promptModule = inquirer_1.default.createPromptModule();
+                const answers = yield promptModule({
                     type: 'checkbox',
                     name: 'extensions',
                     message: 'Which extension(s) would you like to run?',
@@ -100,13 +105,13 @@ class DevModeParentInterface {
             }
             this.isConfigured = true;
             if (typeof setActiveApp === 'function') {
-                yield setActiveApp((_d = (_c = (_b = this.configs) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.appConfig) === null || _d === void 0 ? void 0 : _d.uid);
+                yield setActiveApp((_c = (_b = (_a = this.configs) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.appConfig) === null || _c === void 0 ? void 0 : _c.uid);
             }
         });
     }
-    start(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ requestPorts, accountId, projectConfig, }) {
-            var _b, _c, _d, _e;
+    start({ requestPorts, accountId, projectConfig, }) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
             this.logger.debug('Start function was invoked', {
                 accountId,
                 projectConfig,
@@ -133,7 +138,7 @@ class DevModeParentInterface {
                     this.logger.debug('Call to port manager failed, using default ports');
                 }
             }
-            const { proxy: localDevUrlMapping } = (0, config_1.loadLocalConfig)(((_c = (_b = this.configs) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.path) || '', this.logger) || {};
+            const { proxy: localDevUrlMapping } = (0, config_1.loadLocalConfig)(((_b = (_a = this.configs) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.path) || '', this.logger) || {};
             try {
                 this.devServerState = new DevServerState_1.DevServerState({
                     localDevUrlMapping,
@@ -144,7 +149,7 @@ class DevModeParentInterface {
                     webSocketPort,
                     logger: this.logger,
                     urls: this.urls,
-                    appConfig: (_e = (_d = this.configs) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.appConfig,
+                    appConfig: (_d = (_c = this.configs) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.appConfig,
                 });
             }
             catch (e) {

package/dist/lib/ast.d.ts

@@ -1,15 +1,5 @@
-import { SourceCodeMetadata, SourceCodeChecks, Logger } from './types';
+import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types';
 import { Program, Node } from 'estree';
-type NodeValue = string | number | boolean | null | undefined | RegExp | bigint | NodeValue[] | NodeObject;
-type NodeObject = {
-    [key: string]: NodeValue;
-};
-/**
- * This is a simple utility function to rebuild the value from a node.
- * It'll work for simple stuff, but it's likely to fail in complicated cases.
- * Use with caution!
- */
-export declare function getValueFromNode(node: Node): NodeValue;
 /**
  * We only support image imports that are within the extension directory.
  * This function will check if an image is out of bounds and collect any that are out of bounds, so we can warn the user before they run into build issues.
@@ -22,5 +12,5 @@ export declare function traverseAbstractSyntaxTree(ast: Program, checks: SourceC
         importedHooks: {};
         dependencies: never[];
     };
+    variableDeclarations: Map<string, NodeValue>;
 };
-export {};

package/dist/lib/ast.js

@@ -4,37 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueFromNode = getValueFromNode;
-exports.checkForOutOfBoundsImageImports = checkForOutOfBoundsImageImports;
-exports.traverseAbstractSyntaxTree = traverseAbstractSyntaxTree;
+exports.traverseAbstractSyntaxTree = exports.checkForOutOfBoundsImageImports = void 0;
 const path_1 = __importDefault(require("path"));
 // @ts-expect-error no type defs
 const estraverse_1 = require("estraverse");
 const utils_1 = require("./utils");
-const EXPERIMENTAL_HOOKS = ['useCrmProperties'];
-function _isVariableImported(node, variableName) {
-    if (!node) {
-        return false;
-    }
-    return ((node.type === 'ImportSpecifier' && node.imported.name === variableName) ||
-        (node.type === 'ImportDefaultSpecifier' &&
-            node.local.name === variableName) ||
-        (node.type === 'ImportNamespaceSpecifier' &&
-            node.local.name === variableName));
-}
-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) {
-    return (node.type === 'CallExpression' &&
-        node.callee &&
-        'name' in node.callee &&
-        node.callee.name === functionName);
-}
+const parsing_utils_1 = require("./parsing-utils");
+const PARSED_HOOKS = ['useCrmProperties', 'useAssociations'];
 function _checkForFunctionMetadata(node, parent, output, functionName) {
     if (!node) {
         return;
@@ -42,7 +18,7 @@ function _checkForFunctionMetadata(node, parent, output, functionName) {
     if (!output.functions[functionName]) {
         output.functions[functionName] = {};
     }
-    if (_isFunctionInvoked(node, functionName)) {
+    if ((0, parsing_utils_1.isFunctionInvoked)(node, functionName)) {
         output.functions[functionName].invoked = true;
         // If the function is invoked before being defined we will assume it is a global function
         output.functions[functionName].scope = output.functions[functionName]
@@ -50,56 +26,38 @@ function _checkForFunctionMetadata(node, parent, output, functionName) {
             ? 'Local'
             : 'Global';
     }
-    else if (_isIdentifierDefined(node, parent, functionName) ||
-        _isVariableImported(node, functionName)) {
+    else if ((0, parsing_utils_1.isIdentifierDefined)(node, parent, functionName) ||
+        (0, parsing_utils_1.isVariableImported)(node, functionName)) {
         output.functions[functionName].defined = true;
     }
 }
-/**
- * This is a simple utility function to rebuild the value from a node.
- * It'll work for simple stuff, but it's likely to fail in complicated cases.
- * Use with caution!
- */
-function getValueFromNode(node) {
-    switch (node.type) {
-        case 'Literal':
-            return node.value;
-        case 'Identifier': {
-            const name = node.name;
-            switch (name) {
-                case 'undefined':
-                    return undefined;
-                case 'NaN':
-                    return NaN;
-                case 'Infinity':
-                    return Infinity;
-                default:
-                    return name;
-            }
-        }
-        case 'ArrayExpression':
-            return node.elements.map((element) => element ? getValueFromNode(element) : null);
-        case 'ObjectExpression': {
-            const obj = {};
-            node.properties.forEach((prop) => {
-                if (prop.type === 'Property') {
-                    const property = prop;
-                    let key = undefined;
-                    if (property.key.type === 'Identifier') {
-                        key = property.key.name;
-                    }
-                    else if (property.key.type === 'Literal') {
-                        key = String(property.key.value);
-                    }
-                    if (key) {
-                        obj[key] = getValueFromNode(property.value);
-                    }
+function _collectVariableDeclarations(node, state) {
+    if (!node) {
+        return;
+    }
+    // Handle variable declarations (const, let, var)
+    if (node.type === 'VariableDeclaration') {
+        node.declarations.forEach((declaration) => {
+            if (declaration.type === 'VariableDeclarator' &&
+                declaration.id.type === 'Identifier' &&
+                declaration.init) {
+                const variableName = declaration.id.name;
+                const result = (0, parsing_utils_1.getValueFromNode)(declaration.init, state);
+                if (result.status === 'SUCCESS') {
+                    state.variableDeclarations.set(variableName, result.nodeValue);
                 }
-            });
-            return obj;
+            }
+        });
+    }
+    // Handle assignment expressions for let variables (e.g., myVar = newValue)
+    if (node.type === 'AssignmentExpression' && node.left.type === 'Identifier') {
+        const variableName = node.left.name;
+        if (state.variableDeclarations.has(variableName)) {
+            const result = (0, parsing_utils_1.getValueFromNode)(node.right, state);
+            if (result.status === 'SUCCESS') {
+                state.variableDeclarations.set(variableName, result.nodeValue);
+            }
         }
-        default:
-            return `Unsupported node type: ${node.type}`;
     }
 }
 /**
@@ -124,6 +82,113 @@ function checkForOutOfBoundsImageImports(node, output, extensionPath) {
         }
     }
 }
+exports.checkForOutOfBoundsImageImports = checkForOutOfBoundsImageImports;
+function _processCrmPropertiesHook(node, output) {
+    if (node.type !== 'CallExpression')
+        return;
+    const propertyType = 'CrmRecordProperties';
+    const propertiesNode = node.arguments[0];
+    const optionsNode = node.arguments[1];
+    const requestedProperties = [];
+    const propertiesResult = propertiesNode
+        ? (0, parsing_utils_1.getValueFromNode)(propertiesNode, output)
+        : null;
+    if (propertiesResult &&
+        propertiesResult.status === 'SUCCESS' &&
+        Array.isArray(propertiesResult.nodeValue)) {
+        propertiesResult.nodeValue.forEach((val) => {
+            if (typeof val === 'string') {
+                requestedProperties.push(val);
+            }
+        });
+    }
+    if (requestedProperties.length > 0) {
+        let options = {};
+        const optionsResult = optionsNode
+            ? (0, parsing_utils_1.getValueFromNode)(optionsNode, output)
+            : null;
+        if (optionsResult &&
+            optionsResult.status === 'SUCCESS' &&
+            optionsResult.nodeValue &&
+            typeof optionsResult.nodeValue === 'object' &&
+            !Array.isArray(optionsResult.nodeValue) &&
+            !(optionsResult.nodeValue instanceof RegExp)) {
+            options = optionsResult.nodeValue;
+        }
+        output.dataDependencies.dependencies.push({
+            referenceId: (0, utils_1.generateHash)(propertyType, requestedProperties),
+            properties: {
+                type: propertyType,
+                recordProperties: requestedProperties,
+                options,
+            },
+        });
+    }
+}
+function _processAssociationsHook(node, output) {
+    if (node.type !== 'CallExpression')
+        return;
+    const propertyType = 'CrmRecordAssociationProperties';
+    const requestNode = node.arguments[0];
+    const optionsNode = node.arguments[1];
+    const requestResult = requestNode
+        ? (0, parsing_utils_1.getValueFromNode)(requestNode, output)
+        : null;
+    if (!requestResult ||
+        requestResult.status === 'FAIL' ||
+        !requestResult.nodeValue ||
+        typeof requestResult.nodeValue !== 'object' ||
+        Array.isArray(requestResult.nodeValue)) {
+        return;
+    }
+    const request = requestResult.nodeValue;
+    const toObjectTypeId = request.toObjectType;
+    const requestProperties = request.properties;
+    if (typeof toObjectTypeId !== 'string') {
+        return;
+    }
+    const propertiesArray = [];
+    if (requestProperties && Array.isArray(requestProperties)) {
+        requestProperties.forEach((val) => {
+            if (typeof val === 'string') {
+                propertiesArray.push(val);
+            }
+        });
+    }
+    const paginationOptions = {};
+    const otherOptions = {};
+    const optionsResult = optionsNode
+        ? (0, parsing_utils_1.getValueFromNode)(optionsNode, output)
+        : null;
+    if (optionsResult &&
+        optionsResult.status === 'SUCCESS' &&
+        optionsResult.nodeValue &&
+        typeof optionsResult.nodeValue === 'object' &&
+        !Array.isArray(optionsResult.nodeValue) &&
+        !(optionsResult.nodeValue instanceof RegExp)) {
+        const options = optionsResult.nodeValue;
+        Object.keys(options).forEach((key) => {
+            otherOptions[key] = options[key];
+        });
+    }
+    if (request.pageLength !== undefined) {
+        paginationOptions.pageLength = request.pageLength;
+    }
+    if (request.offset !== undefined) {
+        paginationOptions.offset = request.offset;
+    }
+    const sortedPropertiesForHash = [...propertiesArray].sort();
+    output.dataDependencies.dependencies.push({
+        referenceId: (0, utils_1.generateHash)(propertyType, toObjectTypeId, sortedPropertiesForHash.join('-')),
+        properties: {
+            type: propertyType,
+            toObjectTypeId,
+            requestProperties: propertiesArray,
+            paginationOptions,
+            options: otherOptions,
+        },
+    });
+}
 /**
  * This function collects all internal data dependencies for the extension
  * Specifically, it collects dependencies which are using our custom hooks, eg `useCrmProperties`
@@ -137,13 +202,11 @@ function _collectDataDependencies(node, output, logger) {
         if (node.type === 'ImportDeclaration' &&
             typeof node.source.value === 'string' &&
             node.source.value.startsWith('@hubspot/ui-extensions')) {
-            const isExperimental = node.source.value === '@hubspot/ui-extensions/experimental';
             // If the imports are coming from our own package, loop over them to check for hooks
             node.specifiers.forEach((specifier) => {
                 // If the specifier is an ImportSpecifier and the imported name is one of our tracked hooks, we will track it.
                 if (specifier.type === 'ImportSpecifier' &&
-                    isExperimental &&
-                    EXPERIMENTAL_HOOKS.includes(specifier.imported.name)) {
+                    PARSED_HOOKS.includes(specifier.imported.name)) {
                     // The local name is the name the hook is imported as in the file, and the imported name is the original name of the hook.
                     output.dataDependencies.importedHooks[`${specifier.local.name}`] =
                         specifier.imported.name;
@@ -151,12 +214,10 @@ function _collectDataDependencies(node, output, logger) {
                 else if (
                 // We also have to track namespace level imports
                 specifier.type === 'ImportNamespaceSpecifier') {
-                    // If the specifier is a namespace import, we will track all hooks that are imported from that namespace. Experimental and stable hooks are handled separately.
-                    if (isExperimental) {
-                        EXPERIMENTAL_HOOKS.forEach((hook) => {
-                            output.dataDependencies.importedHooks[`${specifier.local.name}.${hook}`] = hook;
-                        });
-                    }
+                    // If the specifier is a namespace import, we will track all hooks that are imported from that namespace.
+                    PARSED_HOOKS.forEach((hook) => {
+                        output.dataDependencies.importedHooks[`${specifier.local.name}.${hook}`] = hook;
+                    });
                 }
             });
             // Check for calls to our hooks.
@@ -179,55 +240,10 @@ function _collectDataDependencies(node, output, logger) {
             }
             // Then we handle each hook individually, as the usages and tracking format are different.
             if (hookName === 'useCrmProperties') {
-                const propertyType = 'CrmRecordProperties';
-                // Get the first argument, the properties array
-                const propertiesNode = node.arguments[0];
-                const optionsNode = node.arguments[1];
-                const requestedProperties = [];
-                // If the first argument is an array with at least one element, collect the properties.
-                if (propertiesNode &&
-                    propertiesNode.type === 'ArrayExpression' &&
-                    propertiesNode.elements.length > 0) {
-                    propertiesNode.elements.forEach((element) => {
-                        /**
-                         * We only support strings for now, and ignore the rest.
-                         * This might be more generalized in the future as we support more hooks.
-                         */
-                        if (element &&
-                            element.type === 'Literal' &&
-                            typeof element.value === 'string') {
-                            requestedProperties.push(element.value);
-                        }
-                        else {
-                            logger.warn(`Invalid property type in useCrmProperties: ${element ? element.type : 'undefined'}`);
-                        }
-                    });
-                    if (requestedProperties.length > 0) {
-                        let options = {};
-                        if (optionsNode) {
-                            const optionsValue = getValueFromNode(optionsNode);
-                            if (optionsValue !== null &&
-                                optionsValue !== undefined &&
-                                typeof optionsValue === 'object' &&
-                                !Array.isArray(optionsValue) &&
-                                !(optionsValue instanceof RegExp)) {
-                                options = optionsValue;
-                            }
-                        }
-                        output.dataDependencies.dependencies.push({
-                            /**
-                             * This refID is a hash of the property type and the requested properties.
-                             * This should allow us to create the same hash at execution time, to find the correct data from BE.
-                             */
-                            referenceId: (0, utils_1.generateHash)(propertyType, requestedProperties),
-                            properties: {
-                                type: propertyType,
-                                recordProperties: requestedProperties,
-                                options,
-                            },
-                        });
-                    }
-                }
+                _processCrmPropertiesHook(node, output);
+            }
+            else if (hookName === 'useAssociations') {
+                _processAssociationsHook(node, output);
             }
         }
     }
@@ -245,6 +261,7 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
             importedHooks: {},
             dependencies: [],
         },
+        variableDeclarations: new Map(),
     };
     try {
         (0, estraverse_1.traverse)(ast, {
@@ -254,6 +271,7 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
                         _checkForFunctionMetadata(node, parent, state, check.functionName);
                     });
                     checkForOutOfBoundsImageImports(node, state, extensionPath);
+                    _collectVariableDeclarations(node, state);
                     _collectDataDependencies(node, state, logger);
                 }
                 catch (e) {
@@ -268,3 +286,4 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
     }
     return state;
 }
+exports.traverseAbstractSyntaxTree = traverseAbstractSyntaxTree;

package/dist/lib/build.js

@@ -12,9 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensionErrorBaseMessage = void 0;
-exports.buildSingleExtension = buildSingleExtension;
-exports.remoteBuild = remoteBuild;
+exports.remoteBuild = exports.buildSingleExtension = exports.extensionErrorBaseMessage = void 0;
 const vite_1 = require("vite");
 const constants_1 = require("./constants");
 const manifestPlugin_1 = __importDefault(require("./plugins/manifestPlugin"));
@@ -24,9 +22,9 @@ const codeBlockingPlugin_1 = __importDefault(require("./plugins/codeBlockingPlug
 const friendlyLoggingPlugin_1 = __importDefault(require("./plugins/friendlyLoggingPlugin"));
 const allowedExtensions = ['.js', '.ts', '.tsx', '.jsx'];
 exports.extensionErrorBaseMessage = `Supported file extensions are [${allowedExtensions.join(', ')}], received:`;
-function buildSingleExtension(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ file, outputDir = constants_1.OUTPUT_DIR, emptyOutDir = true, minify = false, root = process.cwd(), // This is the vite default, so using that as our default
-    logLevel = 'info', }) {
+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
+logLevel = 'info', }) {
+    return __awaiter(this, void 0, void 0, function* () {
         const output = (0, utils_1.getUrlSafeFileName)(file);
         yield (0, vite_1.build)({
             logLevel,
@@ -53,8 +51,9 @@ function buildSingleExtension(_a) {
         });
     });
 }
-function remoteBuild(root_1, entryPoint_1) {
-    return __awaiter(this, arguments, void 0, function* (root, entryPoint, outputDir = constants_1.OUTPUT_DIR, logLevel) {
+exports.buildSingleExtension = buildSingleExtension;
+function remoteBuild(root, entryPoint, outputDir = constants_1.OUTPUT_DIR, logLevel) {
+    return __awaiter(this, void 0, void 0, function* () {
         const fileInfo = path_1.default.parse(entryPoint);
         if (!allowedExtensions.includes(fileInfo.ext)) {
             throw new Error(`${exports.extensionErrorBaseMessage} ${fileInfo.ext}`);
@@ -68,3 +67,4 @@ function remoteBuild(root_1, entryPoint_1) {
         });
     });
 }
+exports.remoteBuild = remoteBuild;

package/dist/lib/config.js

@@ -5,12 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConfigByPath = loadConfigByPath;
-exports.validateCardConfig = validateCardConfig;
-exports.loadExtensionConfig = loadExtensionConfig;
-exports.validateProxyConfigKey = validateProxyConfigKey;
-exports.validateProxyConfigValue = validateProxyConfigValue;
-exports.loadLocalConfig = loadLocalConfig;
+exports.loadLocalConfig = exports.validateProxyConfigValue = exports.validateProxyConfigKey = exports.loadExtensionConfig = exports.validateCardConfig = exports.loadConfigByPath = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
@@ -18,6 +13,7 @@ function loadConfigByPath(configPath) {
     const source = fs_1.default.readFileSync(configPath).toString();
     return JSON.parse(source);
 }
+exports.loadConfigByPath = loadConfigByPath;
 function validateCardConfig(config) {
     if (!config || typeof config !== 'object') {
         return new Error('Card config must be an object');
@@ -54,6 +50,7 @@ function validateCardConfig(config) {
     }
     return true;
 }
+exports.validateCardConfig = validateCardConfig;
 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;
@@ -84,6 +81,7 @@ function loadExtensionConfig(appConfig, appPath) {
     });
     return outputConfig;
 }
+exports.loadExtensionConfig = loadExtensionConfig;
 function validateProxyConfigKey(urlKey, logger, localConfigPath) {
     try {
         const url = new URL(urlKey);
@@ -95,6 +93,7 @@ function validateProxyConfigKey(urlKey, logger, localConfigPath) {
         logger.warn(`The key "${urlKey}" in "${localConfigPath}" is an invalid url`);
     }
 }
+exports.validateProxyConfigKey = validateProxyConfigKey;
 function validateProxyConfigValue(value, key, logger, localConfigPath) {
     try {
         // eslint-disable-next-line no-new
@@ -104,6 +103,7 @@ function validateProxyConfigValue(value, key, logger, localConfigPath) {
         logger.warn(`The value "${value}" for key "${key}" in "${localConfigPath}" is an invalid url`);
     }
 }
+exports.validateProxyConfigValue = validateProxyConfigValue;
 function loadLocalConfig(appPath, logger) {
     const localConfigFilename = 'local.json';
     const localConfigPath = path_1.default.join(appPath, localConfigFilename);
@@ -125,3 +125,4 @@ function loadLocalConfig(appPath, logger) {
         return undefined;
     }
 }
+exports.loadLocalConfig = loadLocalConfig;

package/dist/lib/dev.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDevMode = startDevMode;
+exports.startDevMode = void 0;
 const vite_1 = require("vite");
 const path_1 = __importDefault(require("path"));
 const server_1 = __importDefault(require("./server"));
@@ -73,3 +73,4 @@ function startDevMode(devServerState) {
         return shutdownServer;
     });
 }
+exports.startDevMode = startDevMode;

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

@@ -0,0 +1,31 @@
+import { Node } from 'estree';
+import { NodeValue, SourceCodeMetadata } from './types';
+/**
+ * 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,
+ * ObjectExpression, SpreadElement, TemplateLiteral, UnaryExpression, and MemberExpression (accessing props on objects).
+ * It also supports nested structures and handles special cases like undefined, NaN, and Infinity.
+ *
+ * It does not handle function calls, complex expressions, or anything that requires evaluation of code logic.
+ * This is not a full JavaScript interpreter, but rather a utility to extract static values from the AST.
+ *
+ * Use this function carefully, as it assumes that the AST is well-formed and that the node types are as expected.
+ * Many types are not yet supported. Anything this function is used for should have a backup runtime evaluation,
+ * or be set up to fail gracefully if parsing fails.
+ *
+ * @param node - The AST node from which to extract the value.
+ * @param state - The current state of the source code metadata, including variable declarations.
+ * @returns An object containing the status of the operation, the extracted node value,
+ *          or an error message if the extraction fails.
+ *          The status can be 'SUCCESS' or 'FAIL'.
+ *          If the status is 'SUCCESS', nodeValue will contain the extracted value.
+ *          If the status is 'FAIL', error will contain the error message.
+ */
+export declare function getValueFromNode(node: Node, state: SourceCodeMetadata): {
+    status: 'SUCCESS' | 'FAIL';
+    nodeValue?: NodeValue;
+    error?: string;
+};
+export declare function isVariableImported(node: Node, variableName: string): boolean;
+export declare function isIdentifierDefined(node: Node, parent: Node | null, name: string): boolean;
+export declare function isFunctionInvoked(node: Node, functionName: string): boolean;

package/dist/lib/parsing-utils.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunctionInvoked = exports.isIdentifierDefined = exports.isVariableImported = exports.getValueFromNode = void 0;
+/**
+ * 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,
+ * ObjectExpression, SpreadElement, TemplateLiteral, UnaryExpression, and MemberExpression (accessing props on objects).
+ * It also supports nested structures and handles special cases like undefined, NaN, and Infinity.
+ *
+ * It does not handle function calls, complex expressions, or anything that requires evaluation of code logic.
+ * This is not a full JavaScript interpreter, but rather a utility to extract static values from the AST.
+ *
+ * Use this function carefully, as it assumes that the AST is well-formed and that the node types are as expected.
+ * Many types are not yet supported. Anything this function is used for should have a backup runtime evaluation,
+ * or be set up to fail gracefully if parsing fails.
+ *
+ * @param node - The AST node from which to extract the value.
+ * @param state - The current state of the source code metadata, including variable declarations.
+ * @returns An object containing the status of the operation, the extracted node value,
+ *          or an error message if the extraction fails.
+ *          The status can be 'SUCCESS' or 'FAIL'.
+ *          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) {
+    try {
+        switch (node.type) {
+            case 'Literal':
+                return { status: 'SUCCESS', nodeValue: node.value };
+            case 'Identifier': {
+                const name = node.name;
+                switch (name) {
+                    case 'undefined':
+                        return { status: 'SUCCESS', nodeValue: undefined };
+                    case 'NaN':
+                        return { status: 'SUCCESS', nodeValue: NaN };
+                    case 'Infinity':
+                        return { status: 'SUCCESS', nodeValue: Infinity };
+                    default:
+                        if (state.variableDeclarations.has(name)) {
+                            return {
+                                status: 'SUCCESS',
+                                nodeValue: state.variableDeclarations.get(name),
+                            };
+                        }
+                        // If for some reason the variable tracking fails, return unsupported.
+                        return { status: 'FAIL', error: `Identifier ${name} is not found` };
+                }
+            }
+            case 'ArrayExpression': {
+                const arrayValue = [];
+                if (node.elements.length === 0) {
+                    return { status: 'SUCCESS', nodeValue: arrayValue };
+                }
+                // Arrays have to be built from their elements, to handle special cases like nested arrays from spread operators.
+                for (const element of node.elements) {
+                    if (typeof element === 'object' && element !== null) {
+                        if (element.type === 'SpreadElement') {
+                            const result = getValueFromNode(element, state);
+                            if (result.status === 'FAIL') {
+                                return {
+                                    status: 'FAIL',
+                                    error: `Array spread element failed: ${result.error}`,
+                                };
+                            }
+                            const value = result.nodeValue;
+                            if (Array.isArray(value)) {
+                                arrayValue.push(...value);
+                            }
+                            else {
+                                arrayValue.push(value);
+                            }
+                        }
+                        else {
+                            const result = getValueFromNode(element, state);
+                            if (result.status === 'FAIL') {
+                                return {
+                                    status: 'FAIL',
+                                    error: `Array element failed: ${result.error}`,
+                                };
+                            }
+                            arrayValue.push(result.nodeValue);
+                        }
+                    }
+                    else {
+                        arrayValue.push(element);
+                    }
+                }
+                return { status: 'SUCCESS', nodeValue: arrayValue };
+            }
+            case 'ObjectExpression': {
+                const obj = {};
+                for (const prop of node.properties) {
+                    switch (prop.type) {
+                        case 'Property': {
+                            const property = prop;
+                            let key = undefined;
+                            if (property.key.type === 'Identifier') {
+                                key = property.key.name;
+                            }
+                            else if (property.key.type === 'Literal') {
+                                key = String(property.key.value);
+                            }
+                            if (key) {
+                                const result = getValueFromNode(property.value, state);
+                                if (result.status === 'FAIL') {
+                                    return {
+                                        status: 'FAIL',
+                                        error: `Object property '${key}' failed: ${result.error}`,
+                                    };
+                                }
+                                obj[key] = result.nodeValue;
+                            }
+                            break;
+                        }
+                        case 'SpreadElement': {
+                            const result = getValueFromNode(prop, state);
+                            if (result.status === 'FAIL') {
+                                return {
+                                    status: 'FAIL',
+                                    error: `Object spread element failed: ${result.error}`,
+                                };
+                            }
+                            const spreadValue = result.nodeValue;
+                            if (spreadValue && typeof spreadValue === 'object') {
+                                Object.assign(obj, spreadValue);
+                            }
+                            break;
+                        }
+                        default:
+                            // Ignore unsupported property types, as we don't have a key for them.
+                            // This could be a computed property or something else we don't handle.
+                            break;
+                    }
+                }
+                return { status: 'SUCCESS', nodeValue: obj };
+            }
+            /**
+             * Spread elements are a bit tricky. They can be used to directly spread an array or object,
+             * or they can be used to spread a variable that is defined elsewhere. Our strategy is to return
+             * whatever element should be spread, and then handle the spreading in the parent array or object.
+             *
+             * There are also trickier cases we don't handle, like spreading a function call that returns an
+             * array or object. When the spread element is unsupported, we return a special symbol.
+             */
+            case 'SpreadElement':
+                if (node.argument) {
+                    if (node.argument.type === 'Identifier' && node.argument.name) {
+                        return {
+                            status: 'SUCCESS',
+                            nodeValue: state.variableDeclarations.get(node.argument.name) || null,
+                        };
+                    }
+                    else if (node.argument.type === 'ArrayExpression' ||
+                        node.argument.type === 'ObjectExpression') {
+                        return getValueFromNode(node.argument, state);
+                    }
+                }
+                return {
+                    status: 'FAIL',
+                    error: `Unsupported SpreadElement type: ${node.argument.type}`,
+                };
+            /**
+             * Template literals are built of an alternating sequence of static
+             * strings and expressions. We will concatenate the static strings and
+             * evaluate the expressions to build the final string.
+             */
+            case 'TemplateLiteral': {
+                let result = '';
+                if (node.expressions && node.quasis) {
+                    const { quasis, expressions } = node;
+                    for (let i = 0; i < quasis.length; i++) {
+                        // Prefer cooked value if available, otherwise use raw.
+                        result += quasis[i].value.cooked || quasis[i].value.raw;
+                        if (i < expressions.length) {
+                            const expression = expressions[i];
+                            const expressionResult = getValueFromNode(expression, state);
+                            if (expressionResult.status === 'SUCCESS') {
+                                const expressionValue = expressionResult.nodeValue;
+                                if (expressionValue === null ||
+                                    expressionValue === undefined ||
+                                    typeof expressionValue === 'string' ||
+                                    typeof expressionValue === 'number' ||
+                                    typeof expressionValue === 'boolean') {
+                                    result += String(expressionValue);
+                                }
+                                else if (Array.isArray(expressionValue)) {
+                                    result += expressionValue.join(',');
+                                }
+                                else if (typeof expressionValue === 'object') {
+                                    result += '[object Object]';
+                                }
+                                else {
+                                    result += `Unsupported TemplateLiteral expression value type: ${typeof expressionValue}`;
+                                }
+                            }
+                            else {
+                                result += expressionResult.error;
+                            }
+                        }
+                    }
+                }
+                return { status: 'SUCCESS', nodeValue: result };
+            }
+            case 'UnaryExpression': {
+                const argResult = getValueFromNode(node.argument, state);
+                if (argResult.status === 'FAIL') {
+                    return argResult;
+                }
+                const arg = argResult.nodeValue;
+                switch (node.operator) {
+                    case '-':
+                        return {
+                            status: 'SUCCESS',
+                            nodeValue: typeof arg === 'number' ? -arg : NaN,
+                        };
+                    case '+':
+                        return {
+                            status: 'SUCCESS',
+                            nodeValue: typeof arg === 'number' ? +arg : NaN,
+                        };
+                    case '!':
+                        return { status: 'SUCCESS', nodeValue: !arg };
+                    case 'typeof':
+                        return { status: 'SUCCESS', nodeValue: typeof arg };
+                    default:
+                        return {
+                            status: 'FAIL',
+                            error: `Unsupported unary operator: ${node.operator}`,
+                        };
+                }
+            }
+            // Member expressions are used to access properties of objects.
+            case 'MemberExpression': {
+                if (node.property.type === 'Identifier' && node.property.name) {
+                    // We have to recursively get the value of the object, due to the way that nested objects are parsed.
+                    const objectResult = getValueFromNode(node.object, state);
+                    if (objectResult.status === 'FAIL') {
+                        return objectResult;
+                    }
+                    const objectData = objectResult.nodeValue;
+                    if (objectData &&
+                        typeof objectData === 'object' &&
+                        !Array.isArray(objectData) &&
+                        !(objectData instanceof RegExp)) {
+                        return {
+                            status: 'SUCCESS',
+                            nodeValue: objectData[node.property.name],
+                        };
+                    }
+                }
+                return {
+                    status: 'FAIL',
+                    error: `Unsupported MemberExpression property type: ${node.property.type}`,
+                };
+            }
+            default:
+                return { status: 'FAIL', error: `Unsupported node type: ${node.type}` };
+        }
+    }
+    catch (error) {
+        return {
+            status: 'FAIL',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+exports.getValueFromNode = getValueFromNode;
+function isVariableImported(node, variableName) {
+    if (!node) {
+        return false;
+    }
+    return ((node.type === 'ImportSpecifier' && node.imported.name === variableName) ||
+        (node.type === 'ImportDefaultSpecifier' &&
+            node.local.name === variableName) ||
+        (node.type === 'ImportNamespaceSpecifier' &&
+            node.local.name === variableName));
+}
+exports.isVariableImported = isVariableImported;
+function isIdentifierDefined(node, parent, name) {
+    if (parent &&
+        (parent.type === 'MemberExpression' || parent.type === 'CallExpression')) {
+        return false;
+    }
+    return node.type === 'Identifier' && node.name === name;
+}
+exports.isIdentifierDefined = isIdentifierDefined;
+function isFunctionInvoked(node, functionName) {
+    return (node.type === 'CallExpression' &&
+        node.callee &&
+        'name' in node.callee &&
+        node.callee.name === functionName);
+}
+exports.isFunctionInvoked = isFunctionInvoked;

package/dist/lib/plugins/codeBlockingPlugin.js

@@ -6,7 +6,7 @@ const ast_1 = require("../ast");
 const codeBlockingPlugin = ({ logger, extensionPath }) => {
     return {
         name: 'ui-extensions-code-blocking-plugin',
-        enforce: 'post', // run after default rollup plugins
+        enforce: 'post',
         transform(code, filename) {
             if ((0, utils_1.isNodeModule)(filename)) {
                 return { code, map: null }; // We don't want to parse node modules
@@ -18,6 +18,7 @@ const codeBlockingPlugin = ({ logger, extensionPath }) => {
                     importedHooks: {},
                     dependencies: [],
                 },
+                variableDeclarations: new Map(),
             };
             const requireFunctionName = 'require';
             try {

package/dist/lib/plugins/devBuildPlugin.js

@@ -17,23 +17,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __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 __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) {
@@ -78,7 +68,7 @@ const devBuildPlugin = (options) => {
                 } }));
         }
     };
-    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 = (server, extensionMetadata, emptyOutDir = false) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const { config: extensionConfig } = extensionMetadata;
             const { extensionPath } = extensionConfig;
@@ -161,7 +151,7 @@ const devBuildPlugin = (options) => {
                 yield devBuild(localServer, devServerState.extensionsMetadata[i], i === 0);
             }
         }),
-        handleHotUpdate: (_a) => __awaiter(void 0, [_a], void 0, function* ({ file, server }) {
+        handleHotUpdate: ({ file, server }) => __awaiter(void 0, void 0, void 0, function* () {
             // If the file is not in the relevantModules list, it's update is inconsequential
             const extensionsToRebuild = devServerState.extensionsMetadata.filter((metadata) => {
                 const { config } = metadata;

package/dist/lib/plugins/manifestPlugin.js

@@ -17,7 +17,7 @@ const manifestPlugin = (options) => {
     let allDataDependencies;
     return {
         name: 'ui-extensions-manifest-generation-plugin',
-        enforce: 'post', // run after default rollup plugins
+        enforce: 'post',
         buildStart() {
             // Reset the source metadata for the new build
             allDataDependencies = [];

package/dist/lib/plugins/relevantModulesPlugin.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelevantModules = getRelevantModules;
+exports.getRelevantModules = void 0;
 const utils_1 = require("../utils");
 const relevantModules = {};
 function getRelevantModules(output) {
     return relevantModules[output] || [];
 }
+exports.getRelevantModules = getRelevantModules;
 const relevantModulesPlugin = ({ output, logger }) => {
     return {
         name: 'ui-extensions-relevant-modules-plugin',

package/dist/lib/server.js

@@ -31,9 +31,9 @@ function listen(app, port) {
         });
     });
 }
-function startDevServer(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ devServerState, viteDevServer, }) {
-        var _b;
+function startDevServer({ devServerState, viteDevServer, }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
         const app = (0, express_1.default)();
         // Setup middleware
         app.use((0, cors_1.default)());
@@ -75,7 +75,7 @@ function startDevServer(_a) {
             }
             throw new Error(e);
         }
-        (_b = devServerState.extensionsMetadata) === null || _b === void 0 ? void 0 : _b.forEach((metadata) => {
+        (_a = devServerState.extensionsMetadata) === null || _a === void 0 ? void 0 : _a.forEach((metadata) => {
             const { baseMessage } = metadata;
             devServerState.logger.debug(`Listening at ${baseMessage.callback}`);
         });

package/dist/lib/types.d.ts

@@ -1,6 +1,5 @@
 import { PLATFORM_VERSION, PRIVATE_APP, PUBLIC_APP } from './constants';
 import { LocalDevUrlMapping } from '@hubspot/app-functions-dev-server';
-import { PromptModule } from 'inquirer';
 export interface ObjectTypes {
     name: string;
 }
@@ -201,13 +200,27 @@ export interface FunctionMetadata {
 export type DataDependency = {
     referenceId: string;
     properties: {
-        type: string;
+        type: 'CrmRecordProperties';
         recordProperties: string[];
         options: {
             [key: string]: any;
         };
+    } | {
+        type: 'CrmRecordAssociationProperties';
+        toObjectTypeId: string;
+        requestProperties: string[];
+        paginationOptions: {
+            [key: string]: any;
+        };
+        options: {
+            [key: string]: any;
+        };
     };
 };
+export type NodeValue = string | number | boolean | null | undefined | RegExp | bigint | symbol | NodeValue[] | NodeObject;
+export type NodeObject = {
+    [key: string]: NodeValue;
+};
 export interface SourceCodeMetadata {
     functions: {
         [functionName: string]: FunctionMetadata;
@@ -219,6 +232,7 @@ export interface SourceCodeMetadata {
         };
         dependencies: DataDependency[];
     };
+    variableDeclarations: Map<string, NodeValue>;
 }
 export interface FunctionInvocationCheck {
     functionName: string;
@@ -246,7 +260,6 @@ export interface DevModeStartArguments {
 }
 export interface DevModeBaseSetupArguments {
     onUploadRequired?: VoidFunction;
-    promptUser: PromptModule;
     logger: Logger;
     urls: {
         api: string;

package/dist/lib/utils.js

@@ -3,17 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnhandledPlatformVersionError = void 0;
-exports.getUrlSafeFileName = getUrlSafeFileName;
-exports.stripAnsiColorCodes = stripAnsiColorCodes;
-exports.loadManifest = loadManifest;
-exports.buildSourceId = buildSourceId;
-exports.isNodeModule = isNodeModule;
-exports.isExtensionFile = isExtensionFile;
-exports.throwUnhandledPlatformVersionError = throwUnhandledPlatformVersionError;
-exports.extractAllowedUrls = extractAllowedUrls;
-exports.generateHash = generateHash;
-exports.isImage = isImage;
+exports.isImage = exports.generateHash = exports.extractAllowedUrls = exports.throwUnhandledPlatformVersionError = exports.UnhandledPlatformVersionError = exports.isExtensionFile = exports.isNodeModule = exports.buildSourceId = exports.loadManifest = exports.stripAnsiColorCodes = exports.getUrlSafeFileName = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const constants_1 = require("./constants");
@@ -21,6 +11,7 @@ function getUrlSafeFileName(filePath) {
     const { name } = path_1.default.parse(filePath);
     return encodeURIComponent(`${name}.js`);
 }
+exports.getUrlSafeFileName = getUrlSafeFileName;
 // Strips ANSI color codes out of strings because we don't want to pass them to the browser
 function stripAnsiColorCodes(stringWithColorCodes) {
     if (!stringWithColorCodes) {
@@ -30,6 +21,7 @@ function stripAnsiColorCodes(stringWithColorCodes) {
     // eslint-disable-next-line no-control-regex
     /[\u001b][[]*([0-9]{1,4};?)*[m]/g, '');
 }
+exports.stripAnsiColorCodes = stripAnsiColorCodes;
 function loadManifest(outputDir, output) {
     try {
         return JSON.parse(fs_1.default
@@ -40,12 +32,14 @@ function loadManifest(outputDir, output) {
         return {};
     }
 }
+exports.loadManifest = loadManifest;
 function buildSourceId(appConfig, extensionConfig) {
     if (appConfig.uid && extensionConfig.data.uid) {
         return `${appConfig.uid}::${extensionConfig.data.uid}`;
     }
     return null;
 }
+exports.buildSourceId = buildSourceId;
 function isNodeModule(filepath) {
     if (!filepath) {
         return false;
@@ -53,6 +47,7 @@ function isNodeModule(filepath) {
     const directory = path_1.default.parse(filepath).dir;
     return directory.includes('node_modules');
 }
+exports.isNodeModule = isNodeModule;
 /**
  * Check if a given file is within the extension path
  */
@@ -72,6 +67,7 @@ function isExtensionFile(filepath, extensionPath) {
         return false;
     }
 }
+exports.isExtensionFile = isExtensionFile;
 class UnhandledPlatformVersionError extends Error {
     constructor(platformVersion) {
         super(`Unsupported platform version "${platformVersion}"`);
@@ -81,12 +77,14 @@ exports.UnhandledPlatformVersionError = UnhandledPlatformVersionError;
 function throwUnhandledPlatformVersionError(platformVersion) {
     throw new UnhandledPlatformVersionError(platformVersion);
 }
+exports.throwUnhandledPlatformVersionError = throwUnhandledPlatformVersionError;
 function extractAllowedUrls(appConfig) {
     if (!appConfig || !('allowedUrls' in appConfig) || !appConfig.allowedUrls) {
         return [];
     }
     return appConfig.allowedUrls;
 }
+exports.extractAllowedUrls = extractAllowedUrls;
 function simpleHash(input) {
     let hash = 0;
     for (let i = 0; i < input.length; i++) {
@@ -122,9 +120,11 @@ function generateHash(...args) {
         return '';
     }
 }
+exports.generateHash = generateHash;
 /**
  * Check if a given URL is an image (of a type we support)
  */
 function isImage(url) {
     return /\.(png|jpg|jpeg|gif|svg|webp|avif|raw|url|inline)$/.test(url);
 }
+exports.isImage = isImage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/ui-extensions-dev-server",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "",
   "bin": {
     "uie": "./dist/lib/bin/cli.js"
@@ -70,5 +70,5 @@
       "optional": true
     }
   },
-  "gitHead": "a5c7f8d19d0dc16b44e9235d3e12dacc2cc14fdf"
+  "gitHead": "8344193a13ab5874924b02d67413dad052558ecf"
 }