@hubspot/ui-extensions-dev-server 0.9.4 → 0.9.8

package/dist/lib/DevModeUnifiedInterface.js

@@ -20,6 +20,14 @@ const constants_1 = require("./constants");
 const types_1 = require("./types");
 const DevModeParentInterface_1 = require("./DevModeParentInterface");
 const utils_1 = require("./utils");
+function getComponentName(componentType) {
+    if (componentType === types_1.UnifiedComponentTypes.SETTINGS) {
+        return 'Settings';
+    }
+    if (componentType === types_1.UnifiedComponentTypes.PAGE) {
+        return 'App Home';
+    }
+}
 class DevModeUnifiedInterface extends DevModeParentInterface_1.DevModeParentInterface {
     _generateAppExtensionMappings(components) {
         var _a, _b, _c, _d;
@@ -62,12 +70,14 @@ class DevModeUnifiedInterface extends DevModeParentInterface_1.DevModeParentInte
         });
         // Build the extension mapping data
         extensionUids.forEach((extensionUid) => {
+            var _a;
             const extension = components[extensionUid];
             // Update the extension entrypoint to be "relative" to the extension directory (eg from /app/card/card.jsx to ./card.jsx)
             extension.config.entrypoint = `./${path_1.default.basename(extension.config.entrypoint)}`;
             // Hardcode the extension name if this is a settings extension (the user does not provide a name for their settings card).
-            if (extension.componentType === types_1.UnifiedComponentTypes.SETTINGS) {
-                extension.config.name = 'Settings';
+            if (extension.componentType === types_1.UnifiedComponentTypes.SETTINGS ||
+                extension.componentType === types_1.UnifiedComponentTypes.PAGE) {
+                extension.config.name = (_a = getComponentName(extension.componentType)) !== null && _a !== void 0 ? _a : '';
             }
             // Add them to the app config
             switch (extension.componentType) {

package/dist/lib/ast.d.ts

@@ -1,11 +1,5 @@
 import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types';
 import { Program, Node } from 'estree';
-/**
- * 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, state: SourceCodeMetadata): 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.

package/dist/lib/ast.js

@@ -4,36 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseAbstractSyntaxTree = exports.checkForOutOfBoundsImageImports = exports.getValueFromNode = void 0;
-const UNSUPPORTED_SPREAD = Symbol('unsupported-spread');
+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;
@@ -41,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]
@@ -49,8 +26,8 @@ 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;
     }
 }
@@ -65,8 +42,10 @@ function _collectVariableDeclarations(node, state) {
                 declaration.id.type === 'Identifier' &&
                 declaration.init) {
                 const variableName = declaration.id.name;
-                const value = getValueFromNode(declaration.init, state);
-                state.variableDeclarations.set(variableName, value);
+                const result = (0, parsing_utils_1.getValueFromNode)(declaration.init, state);
+                if (result.status === 'SUCCESS') {
+                    state.variableDeclarations.set(variableName, result.nodeValue);
+                }
             }
         });
     }
@@ -74,185 +53,13 @@ function _collectVariableDeclarations(node, state) {
     if (node.type === 'AssignmentExpression' && node.left.type === 'Identifier') {
         const variableName = node.left.name;
         if (state.variableDeclarations.has(variableName)) {
-            const value = getValueFromNode(node.right, state);
-            state.variableDeclarations.set(variableName, value);
-        }
-    }
-}
-/**
- * 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, state) {
-    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:
-                    if (state.variableDeclarations.has(name)) {
-                        return state.variableDeclarations.get(name);
-                    }
-                    return name;
-            }
-        }
-        case 'ArrayExpression': {
-            const arrayValue = [];
-            if (node.elements.length === 0) {
-                return arrayValue;
-            }
-            // Arrays have to be built from their elements, to handle special cases like nested arrays from spread operators.
-            node.elements.forEach((element) => {
-                if (typeof element === 'object' && element !== null) {
-                    if (element.type === 'SpreadElement') {
-                        const value = getValueFromNode(element, state);
-                        if (Array.isArray(value)) {
-                            arrayValue.push(...value);
-                        }
-                        else {
-                            arrayValue.push(value);
-                        }
-                    }
-                    else {
-                        const value = getValueFromNode(element, state);
-                        arrayValue.push(value);
-                    }
-                }
-                else {
-                    arrayValue.push(element);
-                }
-            });
-            return arrayValue;
-        }
-        case 'ObjectExpression': {
-            const obj = {};
-            node.properties.forEach((prop) => {
-                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) {
-                            obj[key] = getValueFromNode(property.value, state);
-                        }
-                        break;
-                    }
-                    case 'SpreadElement': {
-                        const spreadValue = getValueFromNode(prop, state);
-                        if (spreadValue !== UNSUPPORTED_SPREAD &&
-                            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 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 state.variableDeclarations.get(node.argument.name) || null;
-                }
-                else if (node.argument.type === 'ArrayExpression' ||
-                    node.argument.type === 'ObjectExpression') {
-                    return getValueFromNode(node.argument, state);
-                }
-            }
-            return UNSUPPORTED_SPREAD;
-        /**
-         * 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 expressionValue = getValueFromNode(expression, state);
-                        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]';
-                        }
-                    }
-                }
-            }
-            return result;
-        }
-        case 'UnaryExpression': {
-            const arg = getValueFromNode(node.argument, state);
-            switch (node.operator) {
-                case '-':
-                    return typeof arg === 'number' ? -arg : NaN;
-                case '+':
-                    return typeof arg === 'number' ? +arg : NaN;
-                case '!':
-                    return !arg;
-                case 'typeof':
-                    return typeof arg;
-                default:
-                    return undefined;
-            }
-        }
-        // 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 objectData = getValueFromNode(node.object, state);
-                if (objectData &&
-                    typeof objectData === 'object' &&
-                    !Array.isArray(objectData) &&
-                    !(objectData instanceof RegExp)) {
-                    return objectData[node.property.name];
-                }
+            const result = (0, parsing_utils_1.getValueFromNode)(node.right, state);
+            if (result.status === 'SUCCESS') {
+                state.variableDeclarations.set(variableName, result.nodeValue);
             }
-            return undefined;
         }
-        default:
-            return `Unsupported node type: ${node.type}`;
     }
 }
-exports.getValueFromNode = getValueFromNode;
 /**
  * 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.
@@ -276,6 +83,112 @@ 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`
@@ -289,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;
@@ -303,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.
@@ -331,49 +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';
-                const propertiesNode = node.arguments[0];
-                const optionsNode = node.arguments[1];
-                const requestedProperties = [];
-                const resolveValue = (astNode) => {
-                    if (!astNode)
-                        return null;
-                    if (astNode.type === 'Identifier' &&
-                        output.variableDeclarations.has(astNode.name)) {
-                        return output.variableDeclarations.get(astNode.name);
-                    }
-                    return getValueFromNode(astNode, output);
-                };
-                const propertiesValue = resolveValue(propertiesNode);
-                if (propertiesValue && Array.isArray(propertiesValue)) {
-                    propertiesValue.forEach((val) => {
-                        if (typeof val === 'string') {
-                            requestedProperties.push(val);
-                        }
-                    });
-                }
-                if (requestedProperties.length > 0) {
-                    let options = {};
-                    const optionsValue = resolveValue(optionsNode);
-                    if (optionsValue &&
-                        typeof optionsValue === 'object' &&
-                        !Array.isArray(optionsValue) &&
-                        !(optionsValue instanceof RegExp)) {
-                        options = optionsValue;
-                    }
-                    output.dataDependencies.dependencies.push({
-                        /**
-                         * This referenceId 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);
             }
         }
     }

package/dist/lib/constants.d.ts

@@ -29,5 +29,6 @@ export declare const PUBLIC_APP = "public-app";
 export declare const PRIVATE_APP = "private-app";
 export declare const CARD_EXTENSION = "CARD";
 export declare const SETTINGS_EXTENSION = "SETTINGS";
+export declare const PAGE_EXTENSION = "PAGE";
 export declare const SUPPORTED_APP_TYPES: string[];
 export declare const SUPPORTED_EXTENSION_TYPES: string[];

package/dist/lib/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_EXTENSION_TYPES = exports.SUPPORTED_APP_TYPES = exports.SETTINGS_EXTENSION = exports.CARD_EXTENSION = exports.PRIVATE_APP = exports.PUBLIC_APP = exports.PLATFORM_VERSION = exports.SERVER_CAPABILITIES = exports.PROXY_CAPABILITY = exports.WEBSOCKET_MESSAGE_VERSION = exports.EXTENSIONS_MESSAGE_VERSION = exports.ROLLUP_OPTIONS = exports.WEBSOCKET_DEFAULT_PORT = exports.EXPRESS_DEFAULT_PORT = exports.VITE_DEV_SERVER_ID = exports.EXPRESS_SERVER_ID = exports.MANIFEST_FILE = exports.OUTPUT_DIR = void 0;
+exports.SUPPORTED_EXTENSION_TYPES = exports.SUPPORTED_APP_TYPES = exports.PAGE_EXTENSION = exports.SETTINGS_EXTENSION = exports.CARD_EXTENSION = exports.PRIVATE_APP = exports.PUBLIC_APP = exports.PLATFORM_VERSION = exports.SERVER_CAPABILITIES = exports.PROXY_CAPABILITY = exports.WEBSOCKET_MESSAGE_VERSION = exports.EXTENSIONS_MESSAGE_VERSION = exports.ROLLUP_OPTIONS = exports.WEBSOCKET_DEFAULT_PORT = exports.EXPRESS_DEFAULT_PORT = exports.VITE_DEV_SERVER_ID = exports.EXPRESS_SERVER_ID = exports.MANIFEST_FILE = exports.OUTPUT_DIR = void 0;
 exports.OUTPUT_DIR = 'dist';
 exports.MANIFEST_FILE = 'manifest.json';
 exports.EXPRESS_SERVER_ID = 'ui-extensions-dev-server';
@@ -41,5 +41,10 @@ exports.PUBLIC_APP = 'public-app';
 exports.PRIVATE_APP = 'private-app';
 exports.CARD_EXTENSION = 'CARD';
 exports.SETTINGS_EXTENSION = 'SETTINGS';
+exports.PAGE_EXTENSION = 'PAGE';
 exports.SUPPORTED_APP_TYPES = [exports.PUBLIC_APP, exports.PRIVATE_APP];
-exports.SUPPORTED_EXTENSION_TYPES = [exports.CARD_EXTENSION, exports.SETTINGS_EXTENSION];
+exports.SUPPORTED_EXTENSION_TYPES = [
+    exports.CARD_EXTENSION,
+    exports.SETTINGS_EXTENSION,
+    exports.PAGE_EXTENSION,
+];

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/types.d.ts

@@ -130,10 +130,11 @@ export type UnifiedCardConfig = {
 export declare enum UnifiedComponentTypes {
     CARD = "CARD",
     APPLICATION = "APPLICATION",
-    SETTINGS = "SETTINGS"
+    SETTINGS = "SETTINGS",
+    PAGE = "PAGE"
 }
 export type UnifiedExtensionComponent = Omit<UnifiedCardConfig, 'type'> & {
-    componentType: UnifiedComponentTypes.CARD | UnifiedComponentTypes.SETTINGS;
+    componentType: UnifiedComponentTypes.CARD | UnifiedComponentTypes.SETTINGS | UnifiedComponentTypes.PAGE;
     componentDeps: {
         app: string;
     };
@@ -200,11 +201,21 @@ 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;

package/dist/lib/types.js

@@ -11,4 +11,5 @@ var UnifiedComponentTypes;
     UnifiedComponentTypes["CARD"] = "CARD";
     UnifiedComponentTypes["APPLICATION"] = "APPLICATION";
     UnifiedComponentTypes["SETTINGS"] = "SETTINGS";
+    UnifiedComponentTypes["PAGE"] = "PAGE";
 })(UnifiedComponentTypes || (exports.UnifiedComponentTypes = UnifiedComponentTypes = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/ui-extensions-dev-server",
-  "version": "0.9.4",
+  "version": "0.9.8",
   "description": "",
   "bin": {
     "uie": "./dist/lib/bin/cli.js"
@@ -70,5 +70,5 @@
       "optional": true
     }
   },
-  "gitHead": "65046f5f3ce4c51652bc454e4425b57bd33aedbf"
+  "gitHead": "68d176099343d6d202421ec241c131f1d07562a8"
 }