@hubspot/ui-extensions-dev-server 1.1.0 → 1.1.2

package/dist/lib/__tests__/server.spec.js

@@ -0,0 +1,152 @@
+import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest';
+import * as devServer from '@hubspot/app-functions-dev-server';
+import startDevServer from "../server.js";
+import { DevServerState } from "../DevServerState.js";
+import { createMockLogger, createDevServerConfig, createMockViteDevServer, } from "./factories.js";
+const useMock = vi.fn();
+vi.mock('@hubspot/app-functions-dev-server', () => ({
+    AppProxyService: vi.fn(() => vi.fn((req, res, next) => next())),
+    AppFunctionExecutionService: vi.fn(() => vi.fn((req, res, next) => next())),
+}));
+vi.mock('express', () => {
+    const expressMock = () => ({
+        use: useMock,
+        get: vi.fn(),
+        listen: (__, callback) => {
+            // simulate async listen
+            const serverMock = {
+                on: vi.fn(function (event) {
+                    if (event === 'error') {
+                        // Don't call error handler in tests
+                    }
+                    return this;
+                }),
+                close: vi.fn((cb) => cb && cb()),
+            };
+            setTimeout(callback, 1);
+            return serverMock;
+        },
+    });
+    expressMock.static = vi.fn(() => vi.fn());
+    return { default: expressMock };
+});
+describe('server', () => {
+    let logger;
+    let devServerConfig;
+    beforeEach(() => {
+        logger = createMockLogger();
+        devServerConfig = createDevServerConfig(logger);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('startDevServer', () => {
+        beforeEach(() => {
+            useMock.mockClear();
+            vi.mocked(devServer.AppFunctionExecutionService).mockReturnValue(vi.fn());
+            vi.mocked(devServer.AppProxyService).mockReturnValue(vi.fn());
+            vi.clearAllMocks();
+        });
+        it('should add the AppProxyService middleware when localDevUrlMapping is provided', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function), 
+            // This is the AppProxyService middleware
+            expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(1);
+            expect(devServer.AppProxyService).toHaveBeenCalledWith({
+                accountId: devServerConfig.accountId,
+                allowedUrls: [],
+                localDevUrlMapping: devServerState.localDevUrlMapping,
+                logger: devServerState.logger,
+            });
+        });
+        it('should not add the AppProxyService middleware when the localDevUrlMapping is empty', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {},
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+        });
+        it('should not add the AppProxyService middleware when localDevUrlMapping is not provided', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: undefined,
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+        });
+        it('should add the AppFunctionExecutionService middleware if is a private app', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServer.AppFunctionExecutionService).toHaveBeenCalledTimes(1);
+        });
+        it('should not add the AppFunctionExecutionService middleware if is a public app', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                appConfig: { isPublicApp: true },
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServer.AppFunctionExecutionService).not.toHaveBeenCalled();
+        });
+        it('should return httpServer and shutdown function', async () => {
+            const devServerState = new DevServerState(devServerConfig);
+            const result = await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(result).toHaveProperty('httpServer');
+            expect(result).toHaveProperty('shutdown');
+            expect(typeof result.shutdown).toBe('function');
+        });
+        it('should initialize ExtensionsWebSocket on devServerState', async () => {
+            const devServerState = new DevServerState(devServerConfig);
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServerState.extensionsWebSocket).toBeDefined();
+        });
+        it('should trigger WebSocket setup after initialization', async () => {
+            const triggerSpy = vi.spyOn(DevServerState.prototype, 'triggerWebSocketSetup');
+            const devServerState = new DevServerState(devServerConfig);
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(triggerSpy).toHaveBeenCalledTimes(1);
+            triggerSpy.mockRestore();
+        });
+    });
+});

package/dist/lib/__tests__/test-utils/ast.d.ts

@@ -0,0 +1 @@
+export declare const localParse: (code: string) => import("acorn").Program;

package/dist/lib/__tests__/test-utils/ast.js

@@ -0,0 +1,4 @@
+import { parse } from 'acorn';
+export const localParse = (code) => {
+    return parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
+};

package/dist/lib/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/utils.spec.js

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach, } from 'vitest';
+import { OUTPUT_DIR } from "../constants.js";
+import { getUrlSafeFileName, stripAnsiColorCodes, loadManifest, buildSourceId, isNodeModule, isExtensionFile, generateHash, } from "../utils.js";
+import fs from 'fs';
+import path from 'path';
+describe('utils', () => {
+    describe('getUrlSafeFileName', () => {
+        it('should uri encode the filename', () => {
+            const fileName = 'test File ?@#$%^&*()Name who would name a file like this!';
+            const actual = getUrlSafeFileName(`${fileName}.tsx`);
+            expect(actual).toEqual(`${encodeURIComponent(fileName)}.js`);
+        });
+    });
+    describe('stripAnsiColorCodes', () => {
+        it('should strip all color codes out of a string', () => {
+            const withColorCodes = '\x1B[33mThis is a test\x1B[39m';
+            const actual = stripAnsiColorCodes(withColorCodes);
+            expect(actual).toEqual('This is a test');
+        });
+        it('should return null if the provided string is null', () => {
+            const actual = stripAnsiColorCodes(undefined);
+            expect(actual).toEqual(null);
+        });
+        it('should return null if the provided string is undefined', () => {
+            const actual = stripAnsiColorCodes(undefined);
+            expect(actual).toEqual(null);
+        });
+        it('should return null if the provided string is empty', () => {
+            const actual = stripAnsiColorCodes('');
+            expect(actual).toEqual(null);
+        });
+    });
+    describe('loadManifest', () => {
+        beforeEach(() => {
+            vi.spyOn(fs, 'readFileSync').mockReturnValue(JSON.stringify({
+                manifest: true,
+            }));
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('should return the manifest file when it is able to load it from disk', () => {
+            const actual = loadManifest(OUTPUT_DIR, 'test-file-name');
+            expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+            expect(actual).toStrictEqual({
+                manifest: true,
+            });
+        });
+        it('should return an empty object when it fails to load from disk', () => {
+            vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
+                throw new Error('OH NO!');
+            });
+            const actual = loadManifest(OUTPUT_DIR, 'test-file-name');
+            expect(actual).toStrictEqual({});
+        });
+    });
+    describe('buildSourceId', () => {
+        it('should return null when there is no uid in app config', () => {
+            expect(buildSourceId({}, { data: { uid: 'some-uid' } })).toBe(null);
+        });
+        it('should return null when there is no uid in extension config', () => {
+            expect(buildSourceId({ uid: 'some-uid' }, { data: {} })).toBe(null);
+        });
+        it('should return a valid sourceId', () => {
+            const appUID = 'app-uid';
+            const extensionUID = 'extension-uid';
+            expect(buildSourceId({ uid: appUID }, { data: { uid: extensionUID } })).toBe(`${appUID}::${extensionUID}`);
+        });
+    });
+    describe('isNodeModule', () => {
+        it('should return false if the path is undefined', () => {
+            expect(isNodeModule(undefined)).toBe(false);
+        });
+        it('should return false if the path is not a node_modules', () => {
+            expect(isNodeModule('foo.js')).toBe(false);
+        });
+        it('should return true if the path is a node_modules', () => {
+            expect(isNodeModule('node_modules/foo.js')).toBe(true);
+        });
+    });
+    describe('isExtensionFile', () => {
+        /**
+         * This function relies on the file system. Mocking doesn't allow us to fully test all scenarios.
+         * In order to effectively test it, we need to create a temporary directory structure.
+         * Being thorough here allows us to safely mock it elsewhere.
+         */
+        const tempDir = path.join(__dirname, 'temp');
+        const extensionDir = path.join(tempDir, 'test/path/extension');
+        const indexFile = path.join(extensionDir, 'index.js');
+        const nestedFile = path.join(extensionDir, 'src/file.ts');
+        const otherFile = path.join(tempDir, 'different/path/file.ts');
+        const relativeOtherFile = path.join(tempDir, '../different/path/file.ts');
+        beforeAll(() => {
+            fs.mkdirSync(extensionDir, { recursive: true });
+            fs.mkdirSync(path.dirname(nestedFile), { recursive: true });
+            fs.mkdirSync(path.dirname(otherFile), { recursive: true });
+            fs.mkdirSync(path.dirname(relativeOtherFile), { recursive: true });
+            fs.writeFileSync(otherFile, '');
+            fs.writeFileSync(nestedFile, '');
+            fs.writeFileSync(indexFile, '');
+            fs.writeFileSync(relativeOtherFile, '');
+        });
+        afterAll(() => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            fs.rmSync(relativeOtherFile, { recursive: true, force: true });
+        });
+        it('should return false if filepath is undefined', () => {
+            expect(isExtensionFile(undefined, extensionDir)).toBe(false);
+        });
+        it('should return true if file is within extension path', () => {
+            expect(isExtensionFile(nestedFile, extensionDir)).toBe(true);
+            expect(isExtensionFile(indexFile, extensionDir)).toBe(true);
+        });
+        it('should return false if file is outside extension path', () => {
+            expect(isExtensionFile(otherFile, extensionDir)).toBe(false);
+        });
+        it('should handle relative paths correctly', () => {
+            const originalCwd = process.cwd();
+            process.chdir(tempDir);
+            expect(isExtensionFile('./test/path/extension/src/file.ts', './test/path/extension')).toBe(true);
+            expect(isExtensionFile('../different/path/file.ts', './test/path/extension')).toBe(false);
+            process.chdir(originalCwd);
+        });
+        it('should return true if the extension path is nested within the provided path', () => {
+            const originalCwd = process.cwd();
+            process.chdir(tempDir);
+            expect(isExtensionFile('../temp/test/path/extension/src/file.ts', './test/path/extension/')).toBe(true);
+            process.chdir(originalCwd);
+        });
+    });
+    describe('generateHash', () => {
+        it('should generate consistent hashes for same inputs', () => {
+            const hash1 = generateHash('test', ['a', 'b'], { foo: 'bar' });
+            const hash2 = generateHash('test', ['a', 'b'], { foo: 'bar' });
+            expect(hash1).toBe(hash2);
+        });
+        it('should handle different types of arguments', () => {
+            expect(generateHash('test')).toBe('364492');
+            expect(generateHash(123)).toBe('be32');
+            expect(generateHash(['a', 'b'])).toBe('171f6');
+            expect(generateHash({ foo: 'bar' })).toBe('4a4201ac');
+            expect(generateHash(null)).toBe('33c587');
+            expect(generateHash(undefined)).toBe('42201c7f');
+        });
+        it('should generate the correct hash for multiple arguments', () => {
+            const hash1 = generateHash('arg1', ['foo', 'bar']);
+            const hash2 = generateHash('test', ['a', 'c', 'd', 'e']);
+            expect(hash1).toBe('1ec304f1');
+            expect(hash2).toBe('607ad458');
+        });
+        it('should normalize arrays regardless of order', () => {
+            const hash1 = generateHash(['a', 'b', 'c']);
+            const hash2 = generateHash(['c', 'a', 'b']);
+            expect(hash1).toBe(hash2);
+        });
+        it('should normalize objects regardless of key order', () => {
+            const hash1 = generateHash({ a: 1, b: 2 });
+            const hash2 = generateHash({ b: 2, a: 1 });
+            expect(hash1).toBe(hash2);
+        });
+        it('should return an empty string and log an error if an error is thrown', () => {
+            // Mock console.error to prevent it from logging to the console
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Create an argument that will cause an error.
+            const circularReference = {};
+            circularReference.self = circularReference;
+            const hash = generateHash(circularReference);
+            expect(hash).toBe('');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error generating hash: ', expect.any(TypeError));
+            // Restore console.error
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});

package/dist/lib/ast.d.ts

@@ -0,0 +1,16 @@
+import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types.ts';
+import { Program, Node } from 'estree';
+/**
+ * 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.
+ */
+export declare function checkForOutOfBoundsImageImports(node: Node, output: SourceCodeMetadata, extensionPath: string): void;
+export declare function traverseAbstractSyntaxTree(ast: Program, checks: SourceCodeChecks, extensionPath: string, logger: Logger): {
+    functions: {};
+    badImports: never[];
+    dataDependencies: {
+        importedHooks: {};
+        dependencies: never[];
+    };
+    variableDeclarations: Map<string, NodeValue>;
+};

package/dist/lib/ast.js

@@ -0,0 +1,281 @@
+import path from 'path';
+// @ts-expect-error no type defs
+import { traverse } from 'estraverse';
+import { generateHash, isExtensionFile, isImage } from "./utils.js";
+import { getValueFromNode, isFunctionInvoked, isIdentifierDefined, isVariableImported, } from "./parsing-utils.js";
+const PARSED_HOOKS = ['useCrmProperties', 'useAssociations'];
+function _checkForFunctionMetadata(node, parent, output, functionName) {
+    if (!node) {
+        return;
+    }
+    if (!output.functions[functionName]) {
+        output.functions[functionName] = {};
+    }
+    if (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]
+            .defined
+            ? 'Local'
+            : 'Global';
+    }
+    else if (isIdentifierDefined(node, parent, functionName) ||
+        isVariableImported(node, functionName)) {
+        output.functions[functionName].defined = true;
+    }
+}
+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 = getValueFromNode(declaration.init, state);
+                if (result.status === 'SUCCESS') {
+                    state.variableDeclarations.set(variableName, result.nodeValue);
+                }
+            }
+        });
+    }
+    // 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 = getValueFromNode(node.right, state);
+            if (result.status === 'SUCCESS') {
+                state.variableDeclarations.set(variableName, result.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.
+ */
+export function checkForOutOfBoundsImageImports(node, output, extensionPath) {
+    if (!node) {
+        return;
+    }
+    if (node.type === 'ImportDeclaration' &&
+        typeof node.source.value === 'string') {
+        const importPath = node.source.value;
+        // Only do the check for images.
+        if (!isImage(importPath)) {
+            return;
+        }
+        // Build the full path to the import, using the extension path as the base.
+        const absoluteImportPath = path.resolve(extensionPath, importPath);
+        if (!isExtensionFile(absoluteImportPath, extensionPath)) {
+            output.badImports.push(importPath);
+        }
+    }
+}
+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
+        ? 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
+            ? 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: 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
+        ? 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
+        ? 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: 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`
+ */
+function _collectDataDependencies(node, output, logger) {
+    if (!node) {
+        return;
+    }
+    try {
+        // Check for imports of our hooks.
+        if (node.type === 'ImportDeclaration' &&
+            typeof node.source.value === 'string' &&
+            node.source.value.startsWith('@hubspot/ui-extensions')) {
+            // 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' &&
+                    specifier.imported.type === 'Identifier' &&
+                    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;
+                }
+                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.
+                    PARSED_HOOKS.forEach((hook) => {
+                        output.dataDependencies.importedHooks[`${specifier.local.name}.${hook}`] = hook;
+                    });
+                }
+            });
+            // Check for calls to our hooks.
+        }
+        else if (node.type === 'CallExpression') {
+            let hookName = '';
+            // This handles the case where the hook is called directly, eg `useCrmProperties()` (also supports aliased hooks)
+            if (node.callee.type === 'Identifier' &&
+                output.dataDependencies.importedHooks[node.callee.name]) {
+                hookName = output.dataDependencies.importedHooks[node.callee.name];
+            }
+            else if (
+            // This handles namespace import usage, eg `uiExtensions.useCrmProperties()`
+            node.callee.type === 'MemberExpression' &&
+                node.callee.object.type === 'Identifier' &&
+                node.callee.property.type === 'Identifier' &&
+                output.dataDependencies.importedHooks[`${node.callee.object.name}.${node.callee.property.name}`]) {
+                hookName =
+                    output.dataDependencies.importedHooks[`${node.callee.object.name}.${node.callee.property.name}`];
+            }
+            // Then we handle each hook individually, as the usages and tracking format are different.
+            if (hookName === 'useCrmProperties') {
+                _processCrmPropertiesHook(node, output);
+            }
+            else if (hookName === 'useAssociations') {
+                _processAssociationsHook(node, output);
+            }
+        }
+    }
+    catch (e) {
+        logger.warn(`Error collecting data dependencies (skipping): ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+// Traverses an ESTree as defined by the EsTree spec https://github.com/estree/estree
+// Uses the checks array to search the source code for matches
+export function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
+    const state = {
+        functions: {},
+        badImports: [],
+        dataDependencies: {
+            importedHooks: {},
+            dependencies: [],
+        },
+        variableDeclarations: new Map(),
+    };
+    try {
+        traverse(ast, {
+            enter(node, parent) {
+                try {
+                    checks.forEach((check) => {
+                        _checkForFunctionMetadata(node, parent, state, check.functionName);
+                    });
+                    checkForOutOfBoundsImageImports(node, state, extensionPath);
+                    _collectVariableDeclarations(node, state);
+                    _collectDataDependencies(node, state, logger);
+                }
+                catch (e) {
+                    // Don't let individual node processing errors crash the entire traverse.
+                    logger.warn(`Error processing node: ${JSON.stringify(node)}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            },
+        });
+    }
+    catch (e) {
+        logger.warn(`Unable to traverse AST: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return state;
+}

package/dist/lib/bin/cli.d.ts

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