@hubspot/project-parsing-lib 0.10.3-beta.0 → 0.11.0-beta.0

package/src/lib/transform.js

@@ -1,24 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToInternalType = mapToInternalType;
-exports.mapToUserFacingType = mapToUserFacingType;
-exports.mapToUserFriendlyName = mapToUserFriendlyName;
-exports.findTransformationByUid = findTransformationByUid;
-exports.transform = transform;
-exports.getIntermediateRepresentation = getIntermediateRepresentation;
-exports.getParsingErrors = getParsingErrors;
-exports.generateServerlessPackageComponent = generateServerlessPackageComponent;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const profiles_1 = require("./profiles");
-const constants_1 = require("./constants");
-const copy_1 = require("../lang/copy");
-const utils_1 = require("./utils");
-const files_1 = require("./files");
+import path from 'path';
+import fs from 'fs';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { applyHsProfileVariables, getHsProfileVariables } from './profiles.js';
+import { APP_KEY, APP_OBJECT_KEY, Components, PROJECT_STRUCTURE, APP_FUNCTIONS_KEY, APP_FUNCTIONS_PACKAGE_KEY, USER_FACING_TO_INTERNAL_TYPE, INTERNAL_TYPE_TO_USER_FACING, PACKAGE_JSON, PACKAGE_LOCK_JSON, PROFILE_VARIABLE_TYPES, } from './constants.js';
+import { errorMessages } from '../lang/copy.js';
+import { getJavaNumberType } from './utils.js';
+import { convertPathToPosixPath } from './files.js';
 function calculateComponentDeps(fileValidationResult, parentComponents, appObjects, appFunctionsPackageUid) {
     let dependencies = {};
     // If there are dependencies in the config file, pass them through
@@ -27,65 +14,65 @@ function calculateComponentDeps(fileValidationResult, parentComponents, appObjec
     }
     const { type } = fileValidationResult.content;
     // If the component is a child of the App component, add the app and appObjects as dependencies
-    if (constants_1.Components[type]?.parentComponent === constants_1.AppKey) {
-        const parentUid = parentComponents[constants_1.AppKey];
+    if (Components[type]?.parentComponent === APP_KEY) {
+        const parentUid = parentComponents[APP_KEY];
         if (parentUid) {
             dependencies.app = parentUid;
         }
         else {
-            logger_1.logger.debug(parentComponents);
+            logger.debug(parentComponents);
             return {
                 dependencies,
-                errors: [copy_1.errorMessages.project.mustHaveAppComponent(type)],
+                errors: [errorMessages.project.mustHaveAppComponent(type)],
             };
         }
-        if (type !== constants_1.AppObjectKey) {
+        if (type !== APP_OBJECT_KEY) {
             dependencies.allAppObjects = appObjects;
         }
-        if (type === constants_1.AppFunctionsKey && appFunctionsPackageUid) {
+        if (type === APP_FUNCTIONS_KEY && appFunctionsPackageUid) {
             dependencies.serverlessPackage = appFunctionsPackageUid;
         }
     }
     return { dependencies };
 }
-function mapToInternalType(type) {
-    const resolvedType = constants_1.userFacingToInternalType[type] || type || '';
+export function mapToInternalType(type) {
+    const resolvedType = USER_FACING_TO_INTERNAL_TYPE[type] || type || '';
     return resolvedType.toUpperCase().replace(/-/g, '_');
 }
-function mapToUserFacingType(type) {
-    return (constants_1.internalTypeToUserFacing[type] || type || '')
+export function mapToUserFacingType(type) {
+    return (INTERNAL_TYPE_TO_USER_FACING[type] || type || '')
         .toLowerCase()
         .replace(/_/g, '-');
 }
-function mapToUserFriendlyName(internalType) {
-    return constants_1.Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
+export function mapToUserFriendlyName(internalType) {
+    return Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
 }
-function findTransformationByUid(transformations, uid) {
+export function findTransformationByUid(transformations, uid) {
     return transformations.find(t => t.intermediateRepresentation?.uid === uid);
 }
-function transform(fileParseResults, translationContext, hsProfileContents) {
-    const parentTypes = Object.keys(constants_1.ProjectStructure);
+export function transform(fileParseResults, translationContext, hsProfileContents) {
+    const parentTypes = Object.keys(PROJECT_STRUCTURE);
     const parentComponents = {};
     const allAppObjects = [];
     let appUid = '';
     let appFunctionsDirectory;
     // Apply the profile variable overrides to the config
     if (hsProfileContents) {
-        fileParseResults = (0, profiles_1.applyHsProfileVariables)(fileParseResults, hsProfileContents);
+        fileParseResults = applyHsProfileVariables(fileParseResults, hsProfileContents);
     }
     // Compute the parent components, so we can add them as dependencies to the child components
     fileParseResults.forEach(file => {
         if (file.content?.type && parentTypes.includes(file.content.type)) {
-            if (file.content.type === constants_1.AppKey) {
+            if (file.content.type === APP_KEY) {
                 appUid = file.content.uid;
             }
             parentComponents[file.content.type] = file.content.uid;
         }
-        if (file.content?.type === constants_1.AppObjectKey) {
+        if (file.content?.type === APP_OBJECT_KEY) {
             allAppObjects.push(file.content.uid);
         }
-        if (file.content?.type === constants_1.AppFunctionsKey) {
-            appFunctionsDirectory = path_1.default.dirname(file.file);
+        if (file.content?.type === APP_FUNCTIONS_KEY) {
+            appFunctionsDirectory = path.dirname(file.file);
         }
     });
     const autoGeneratedComponents = [];
@@ -100,8 +87,8 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
     }
     const transformations = fileParseResults.map((currentFile) => {
         if (!currentFile.content) {
-            if (!currentFile.errors?.includes(copy_1.errorMessages.validation.invalidJson)) {
-                currentFile.errors?.push(copy_1.errorMessages.project.fileContentMissingFor(currentFile.file));
+            if (!currentFile.errors?.includes(errorMessages.validation.invalidJson)) {
+                currentFile.errors?.push(errorMessages.project.fileContentMissingFor(currentFile.file));
             }
             return {
                 intermediateRepresentation: null,
@@ -119,7 +106,7 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
                 config,
                 componentType: mapToInternalType(type),
                 componentDeps: dependencies,
-                metaFilePath: (0, files_1.convertPathToPosixPath)(currentFile.file),
+                metaFilePath: convertPathToPosixPath(currentFile.file),
                 files: {},
             },
             fileParseResult: currentFile,
@@ -127,7 +114,7 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
     });
     return [...autoGeneratedComponents, ...transformations];
 }
-function getIntermediateRepresentation(transformations, hsProfileContents, skipValidation) {
+export function getIntermediateRepresentation(transformations, hsProfileContents, skipValidation) {
     const nodes = transformations.reduce((acc, current) => {
         if (!current.intermediateRepresentation) {
             return acc;
@@ -137,15 +124,14 @@ function getIntermediateRepresentation(transformations, hsProfileContents, skipV
             const duplicates = transformations
                 .filter(t => t.intermediateRepresentation?.uid === uid)
                 .map(t => t.fileParseResult.file);
-            throw new Error(copy_1.errorMessages.project.duplicateUid(uid, duplicates));
+            throw new Error(errorMessages.project.duplicateUid(uid, duplicates));
         }
         if (!skipValidation) {
             return {
                 ...acc,
                 // If the uid is not defined just make one up for the sake of indexing.
                 // It will still fail validation, but this prevents collisions so we validate all files.
-                [uid ||
-                    `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
+                [uid || `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
             };
         }
         return {
@@ -159,7 +145,7 @@ function getIntermediateRepresentation(transformations, hsProfileContents, skipV
         profileData,
     };
 }
-function getParsingErrors(transformations) {
+export function getParsingErrors(transformations) {
     return transformations
         .filter(t => t.fileParseResult.errors.length > 0)
         .map(t => t.fileParseResult);
@@ -167,19 +153,19 @@ function getParsingErrors(transformations) {
 function getProfileData(hsProfileContents) {
     const profileVariablesForBE = {};
     if (hsProfileContents && hsProfileContents.variables) {
-        const profileVariables = (0, profiles_1.getHsProfileVariables)(hsProfileContents);
+        const profileVariables = getHsProfileVariables(hsProfileContents);
         Object.keys(profileVariables).forEach(key => {
             const profileVar = profileVariables[key];
             let variableTypeForBE;
             switch (typeof profileVar) {
                 case 'string':
-                    variableTypeForBE = constants_1.ProfileVariableTypes.PROFILE_STRING;
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_STRING;
                     break;
                 case 'number':
-                    variableTypeForBE = (0, utils_1.getJavaNumberType)(profileVar);
+                    variableTypeForBE = getJavaNumberType(profileVar);
                     break;
                 case 'boolean':
-                    variableTypeForBE = constants_1.ProfileVariableTypes.PROFILE_BOOLEAN;
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_BOOLEAN;
                     break;
                 default:
                     break;
@@ -194,14 +180,14 @@ function getProfileData(hsProfileContents) {
     }
     return { vars: { profileVariables: profileVariablesForBE } };
 }
-function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
-    const appFunctionsPosix = (0, files_1.convertPathToPosixPath)(appFunctionsDirectory);
-    const packageFilePosix = path_1.default.posix.join(appFunctionsPosix, constants_1.packageJson);
-    const packageLockFilePosix = path_1.default.posix.join(appFunctionsPosix, constants_1.packageLockJson);
-    const projectSourceDirPosix = (0, files_1.convertPathToPosixPath)(translationContext.projectSourceDir);
-    const appFunctionsPackageFile = path_1.default.posix.join(projectSourceDirPosix, packageFilePosix);
-    if (!fs_1.default.existsSync(appFunctionsPackageFile)) {
-        throw new Error(copy_1.errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
+export function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
+    const appFunctionsPosix = convertPathToPosixPath(appFunctionsDirectory);
+    const packageFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_JSON);
+    const packageLockFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_LOCK_JSON);
+    const projectSourceDirPosix = convertPathToPosixPath(translationContext.projectSourceDir);
+    const appFunctionsPackageFile = path.posix.join(projectSourceDirPosix, packageFilePosix);
+    if (!fs.existsSync(appFunctionsPackageFile)) {
+        throw new Error(errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
     }
     const uid = `hubspot-serverless-package-uid`;
     return {
@@ -213,12 +199,12 @@ function generateServerlessPackageComponent(appFunctionsDirectory, translationCo
             },
             intermediateRepresentation: {
                 uid,
-                componentType: mapToInternalType(constants_1.AppFunctionsPackageKey),
+                componentType: mapToInternalType(APP_FUNCTIONS_PACKAGE_KEY),
                 config: {
                     packageFile: packageFilePosix,
-                    packageLockfile: fs_1.default.existsSync(
+                    packageLockfile: fs.existsSync(
                     // Don't use posix here because we are checking the file system
-                    path_1.default.join(translationContext.projectSourceDir, path_1.default.join(appFunctionsDirectory, constants_1.packageLockJson)))
+                    path.join(translationContext.projectSourceDir, path.join(appFunctionsDirectory, PACKAGE_LOCK_JSON)))
                         ? packageLockFilePosix
                         : undefined,
                 },

package/src/lib/translate.d.ts

@@ -0,0 +1,3 @@
+import { IntermediateRepresentation, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, TranslationOptionsLocalDev } from './types.js';
+export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<IntermediateRepresentation>;
+export declare function translateForLocalDev(translationContext: TranslationContext, translationOptions?: TranslationOptionsLocalDev): Promise<IntermediateRepresentationLocalDev>;

package/src/lib/translate.js

@@ -0,0 +1,52 @@
+import { loadHsProfileFile, loadHsMetaFiles } from './files.js';
+import { validateIntermediateRepresentation } from './validation.js';
+import { getIntermediateRepresentation, getParsingErrors, transform, } from './transform.js';
+import { errorMessages } from '../lang/copy.js';
+import { getLocalDevProfileData, getLocalDevProjectNodes, getRemovedNodesAndNodesWithErrors, } from './localDev.js';
+const defaultOptions = {
+    skipValidation: false,
+};
+export async function translate(translationContext, translationOptions = defaultOptions) {
+    const { skipValidation } = translationOptions;
+    const metafileContents = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (translationOptions.profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, translationOptions.profile);
+    }
+    const transformations = transform(metafileContents, translationContext, hsProfileContents);
+    const intermediateRepresentation = getIntermediateRepresentation(transformations, hsProfileContents, skipValidation);
+    // Remove once extensions and serverless functions are supported
+    if (!skipValidation) {
+        await validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext);
+    }
+    return intermediateRepresentation;
+}
+export async function translateForLocalDev(translationContext, translationOptions) {
+    const metafileContents = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (translationOptions?.profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, translationOptions.profile);
+    }
+    const transformation = transform(metafileContents, translationContext, hsProfileContents);
+    const baseIntermediateRepresentation = getIntermediateRepresentation(transformation, hsProfileContents, true);
+    const parsingErrors = getParsingErrors(transformation);
+    const projectNodes = getLocalDevProjectNodes(baseIntermediateRepresentation.intermediateNodesIndexedByUid, translationContext.projectSourceDir, translationOptions?.projectNodesAtLastUpload);
+    let projectNodesWithErrors = {};
+    if (translationOptions?.projectNodesAtLastUpload) {
+        projectNodesWithErrors = getRemovedNodesAndNodesWithErrors(baseIntermediateRepresentation.intermediateNodesIndexedByUid, translationOptions.projectNodesAtLastUpload, parsingErrors);
+    }
+    const profileData = getLocalDevProfileData(baseIntermediateRepresentation.profileData?.vars.profileVariables);
+    return {
+        intermediateNodesIndexedByUid: {
+            ...projectNodes,
+            ...projectNodesWithErrors,
+        },
+        profileData,
+    };
+}

package/src/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { ErrorObject } from 'ajv/dist/2020';
+import type { ErrorObject } from 'ajv';
 export type Dependencies = Record<string, string | string[]>;
 export interface Components {
     uid: string;

package/src/lib/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/src/lib/uid.js

@@ -1,25 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_UID_LENGTH = void 0;
-exports.validateUid = validateUid;
-exports.coerceToValidUid = coerceToValidUid;
-const copy_1 = require("../lang/copy");
-exports.MAX_UID_LENGTH = 64;
-function validateUid(uid) {
+import { errorMessages } from '../lang/copy.js';
+export const MAX_UID_LENGTH = 64;
+export function validateUid(uid) {
     if (uid === '' || !uid) {
-        return copy_1.errorMessages.validation.emptyUid;
+        return errorMessages.validation.emptyUid;
     }
-    if (uid.length > exports.MAX_UID_LENGTH) {
-        return copy_1.errorMessages.validation.uidTooLong;
+    if (uid.length > MAX_UID_LENGTH) {
+        return errorMessages.validation.uidTooLong;
     }
     if (!/^[a-zA-Z0-9_\-.]+$/.test(uid)) {
-        return copy_1.errorMessages.validation.invalidUid;
+        return errorMessages.validation.invalidUid;
     }
 }
-function coerceToValidUid(potentialUid) {
+export function coerceToValidUid(potentialUid) {
     if (typeof potentialUid !== 'string') {
         return undefined;
     }
     const newUid = potentialUid.replace(/[^a-zA-Z0-9_\-.]/g, '');
-    return newUid.length === 0 ? undefined : newUid.substring(0, exports.MAX_UID_LENGTH);
+    return newUid.length === 0 ? undefined : newUid.substring(0, MAX_UID_LENGTH);
 }

package/src/lib/utils.d.ts

@@ -1,3 +1,3 @@
-import { BEProfileVariableType } from './types';
+import { BEProfileVariableType } from './types.js';
 export declare function loadJsonFile(filename: string): any;
 export declare function getJavaNumberType(value: number): BEProfileVariableType;

package/src/lib/utils.js

@@ -1,23 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadJsonFile = loadJsonFile;
-exports.getJavaNumberType = getJavaNumberType;
-const fs_1 = __importDefault(require("fs"));
-const constants_1 = require("./constants");
-function loadJsonFile(filename) {
-    return JSON.parse(fs_1.default.readFileSync(filename, {
+import fs from 'fs';
+import { PROFILE_VARIABLE_TYPES } from './constants.js';
+export function loadJsonFile(filename) {
+    return JSON.parse(fs.readFileSync(filename, {
         encoding: 'utf-8',
     }));
 }
-function getJavaNumberType(value) {
+export function getJavaNumberType(value) {
     const JAVA_INT_MIN = -2_147_483_648;
     const JAVA_INT_MAX = 2_147_483_647;
     // Check if the value fits in Java int range
     if (value >= JAVA_INT_MIN && value <= JAVA_INT_MAX) {
-        return constants_1.ProfileVariableTypes.PROFILE_INT;
+        return PROFILE_VARIABLE_TYPES.PROFILE_INT;
     }
-    return constants_1.ProfileVariableTypes.PROFILE_LONG;
+    return PROFILE_VARIABLE_TYPES.PROFILE_LONG;
 }

package/src/lib/validation.d.ts

@@ -1,5 +1,5 @@
-import { CompiledError, IntermediateRepresentation, Transformation, TranslationContext } from './types';
-import Ajv, { ValidateFunction } from 'ajv/dist/2020';
+import { CompiledError, IntermediateRepresentation, Transformation, TranslationContext } from './types.js';
+import { Ajv2020, ValidateFunction } from 'ajv/dist/2020.js';
 export type ValidResult = {
     valid: true;
     errors?: null;
@@ -10,5 +10,5 @@ export type ValidationResults = {
     errors?: CompiledError;
     schemaValidationErrors?: ValidateFunction['errors'];
 } | ValidResult;
-export declare function createAjvInstance(): Ajv;
+export declare function createAjvInstance(): Ajv2020;
 export declare function validateIntermediateRepresentation(intermediateRepresentation: IntermediateRepresentation, transformations: Transformation[], translationContext: TranslationContext): Promise<ValidResult>;

package/src/lib/validation.js

@@ -1,26 +1,25 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAjvInstance = createAjvInstance;
-exports.validateIntermediateRepresentation = validateIntermediateRepresentation;
-const schemas_1 = require("./schemas");
-const _2020_1 = __importDefault(require("ajv/dist/2020"));
-const errors_1 = require("./errors");
-const copy_1 = require("../lang/copy");
-const constants_1 = require("./constants");
-const path_1 = __importDefault(require("path"));
-const transform_1 = require("./transform");
-const ajv_formats_1 = __importDefault(require("ajv-formats"));
-const uid_1 = require("./uid");
-function createAjvInstance() {
-    const ajv = new _2020_1.default({ allErrors: true });
-    (0, ajv_formats_1.default)(ajv);
+import { getIntermediateRepresentationSchema } from './schemas.js';
+import { Ajv2020, } from 'ajv/dist/2020.js';
+import { compileError, TranslationError } from './errors.js';
+import { errorMessages } from '../lang/copy.js';
+import { AUTO_GENERATED_COMPONENT_TYPES, Components } from './constants.js';
+import path from 'path';
+import { findTransformationByUid, mapToUserFacingType } from './transform.js';
+import { validateUid } from './uid.js';
+// ajv-formats does not play nicely with ESM and TS
+import addFormatsModule from 'ajv-formats';
+const addFormats = addFormatsModule;
+export function createAjvInstance() {
+    const ajv = new Ajv2020({
+        allErrors: true,
+        code: { esm: true },
+        strict: false, // Allow Draft 2020-12 features
+    });
+    addFormats(ajv);
     return ajv;
 }
 function validateIntermediateRepresentationNode(schema, transformation, irNode, translationContext) {
-    if (constants_1.AutoGeneratedComponentTypes.includes((0, transform_1.mapToUserFacingType)(irNode.componentType))) {
+    if (AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(irNode.componentType))) {
         // Skip validation for auto-generated components
         return {
             valid: true,
@@ -29,51 +28,51 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
     if (transformation.fileParseResult.errors.length > 0) {
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformation),
+            errors: compileError(transformation),
         };
     }
     const ajv = createAjvInstance();
     let shouldSkipValidation = false;
     if (!irNode.uid) {
-        transformation.fileParseResult.errors.push(copy_1.errorMessages.validation.missingUid);
+        transformation.fileParseResult.errors.push(errorMessages.validation.missingUid);
     }
     else {
-        const uidValidationResult = (0, uid_1.validateUid)(irNode.uid);
+        const uidValidationResult = validateUid(irNode.uid);
         if (uidValidationResult) {
             transformation.fileParseResult.errors.push(uidValidationResult);
         }
     }
     if (!irNode.config) {
-        transformation.fileParseResult.errors.push(copy_1.errorMessages.validation.missingConfig);
+        transformation.fileParseResult.errors.push(errorMessages.validation.missingConfig);
         // If there is no config block, there is nothing to validation
         shouldSkipValidation = true;
     }
     if (!schema[irNode.componentType]) {
         if (!irNode.componentType) {
-            transformation.fileParseResult.errors.push(copy_1.errorMessages.validation.missingType);
+            transformation.fileParseResult.errors.push(errorMessages.validation.missingType);
         }
         else {
-            transformation.fileParseResult.errors.push(copy_1.errorMessages.validation.unsupportedType(irNode.componentType));
+            transformation.fileParseResult.errors.push(errorMessages.validation.unsupportedType(irNode.componentType));
         }
         // If there is no schema for the component type, there is no way to validate
         shouldSkipValidation = true;
     }
-    const userFacingType = (0, transform_1.mapToUserFacingType)(irNode.componentType);
-    const component = constants_1.Components[userFacingType];
+    const userFacingType = mapToUserFacingType(irNode.componentType);
+    const component = Components[userFacingType];
     if (userFacingType && component) {
         const expectedParentDir = component.parentComponent
-            ? constants_1.Components[component.parentComponent].dir
+            ? Components[component.parentComponent].dir
             : '';
-        const expectedLocation = path_1.default.join(expectedParentDir, component.dir);
-        const actualLocation = path_1.default.dirname(transformation.fileParseResult.file);
+        const expectedLocation = path.join(expectedParentDir, component.dir);
+        const actualLocation = path.dirname(transformation.fileParseResult.file);
         if (expectedLocation !== actualLocation) {
-            transformation.fileParseResult.errors.push(copy_1.errorMessages.validation.wrongDirectoryForComponent(actualLocation, userFacingType, component, path_1.default.join(translationContext.projectSourceDir, expectedLocation)));
+            transformation.fileParseResult.errors.push(errorMessages.validation.wrongDirectoryForComponent(actualLocation, userFacingType, component, path.join(translationContext.projectSourceDir, expectedLocation)));
         }
     }
     if (shouldSkipValidation) {
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformation),
+            errors: compileError(transformation),
         };
     }
     const validate = ajv.compile(schema[irNode.componentType]);
@@ -87,7 +86,7 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
             }
             : {
                 valid: false,
-                errors: (0, errors_1.compileError)(transformation),
+                errors: compileError(transformation),
             };
     }
     return {
@@ -95,21 +94,22 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
         schemaValidationErrors: validate.errors,
     };
 }
-async function validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext) {
+export async function validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext) {
     const hasAnyFileParseErrors = transformations.some(t => t.fileParseResult.errors.length > 0);
-    const schema = await (0, schemas_1.getIntermediateRepresentationSchema)(translationContext);
+    const schema = await getIntermediateRepresentationSchema(translationContext);
     const potentialDuplicatesByComponent = {};
     const results = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).map(irNode => {
-        const userFacingType = (0, transform_1.mapToUserFacingType)(irNode.componentType);
-        const component = constants_1.Components[userFacingType];
+        const userFacingType = mapToUserFacingType(irNode.componentType);
+        const component = Components[userFacingType];
         if (component && component.singularComponent) {
-            potentialDuplicatesByComponent[userFacingType] = potentialDuplicatesByComponent[userFacingType]
-                ? [...potentialDuplicatesByComponent[userFacingType], irNode]
-                : [irNode];
+            potentialDuplicatesByComponent[userFacingType] =
+                potentialDuplicatesByComponent[userFacingType]
+                    ? [...potentialDuplicatesByComponent[userFacingType], irNode]
+                    : [irNode];
         }
-        const transformation = (0, transform_1.findTransformationByUid)(transformations, irNode.uid);
+        const transformation = findTransformationByUid(transformations, irNode.uid);
         if (!transformation) {
-            return { valid: false, errors: [copy_1.errorMessages.validation.missingUid] };
+            return { valid: false, errors: [errorMessages.validation.missingUid] };
         }
         return validateIntermediateRepresentationNode(schema, transformation, irNode, translationContext);
     });
@@ -120,9 +120,9 @@ async function validateIntermediateRepresentation(intermediateRepresentation, tr
         }
         hasDuplicates = true;
         potentialDuplicates.forEach(duplicate => {
-            const potentialDuplicateTransformation = (0, transform_1.findTransformationByUid)(transformations, duplicate.uid);
+            const potentialDuplicateTransformation = findTransformationByUid(transformations, duplicate.uid);
             if (potentialDuplicateTransformation) {
-                potentialDuplicateTransformation.fileParseResult.errors.push(copy_1.errorMessages.project.duplicateComponent(componentType));
+                potentialDuplicateTransformation.fileParseResult.errors.push(errorMessages.project.duplicateComponent(componentType));
             }
         });
     });
@@ -135,5 +135,5 @@ async function validateIntermediateRepresentation(intermediateRepresentation, tr
         };
     }
     const schemaValidationErrors = results.map(result => 'schemaValidationErrors' in result ? result.schemaValidationErrors : null);
-    throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, transformations, schemaValidationErrors, translationContext);
+    throw new TranslationError(errorMessages.project.failedToTranslateProject, transformations, schemaValidationErrors, translationContext);
 }

package/src/index.d.ts

@@ -1,19 +0,0 @@
-import { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, IntermediateRepresentationNodeLocalDev, TranslationOptionsLocalDev } from './lib/types';
-import { ValidateFunction, AnySchema, ErrorObject } from 'ajv/dist/2020';
-export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<IntermediateRepresentation>;
-export declare function translateForLocalDev(translationContext: TranslationContext, translationOptions?: TranslationOptionsLocalDev): Promise<IntermediateRepresentationLocalDev>;
-export { isTranslationError } from './lib/errors';
-export { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, IntermediateRepresentationNodeLocalDev, TranslationContext, };
-export { getHsProfileFilename, validateProfileVariables } from './lib/profiles';
-export { loadHsProfileFile, getAllHsProfiles, projectContainsHsMetaFiles, } from './lib/files';
-export { migrate } from './lib/migrate';
-export { validateUid, coerceToValidUid } from './lib/uid';
-export { mapToUserFriendlyName, mapToInternalType } from './lib/transform';
-export { getIntermediateRepresentationSchema } from './lib/schemas';
-export { createAjvInstance } from './lib/validation';
-export { ValidateFunction, AnySchema, ErrorObject };
-export { metafileExtension, hsProjectJsonFilename } from './lib/constants';
-export { Components } from './lib/types';
-export { AjvErrorKeyword } from './lib/errors';
-export { getInvalidJsonError, getMissingTypeError, getMissingConfigError, getMissingAccountIdError, getMissingRequiredFieldError, getFailedToFetchSchemasError, getUnsupportedTypeError, } from './lang/copy';
-export { migrateThemes, getProjectThemeDetails } from './lib/migrateThemes';