piral-cli 0.15.0-alpha.4122 → 0.15.0-alpha.4284

package/src/common/npm.ts

@@ -1,65 +1,60 @@
 import { resolve, relative, dirname, isAbsolute, sep } from 'path';
-import { createReadStream, existsSync, access, constants } from 'fs';
+import { createReadStream, existsSync } from 'fs';
 import { log, fail } from './log';
+import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
 import { legacyCoreExternals, frameworkLibs } from './constants';
 import { inspectPackage } from './inspect';
-import { readJson, checkExists, findFile } from './io';
+import { readJson, checkExists } from './io';
 import { clientTypeKeys } from '../helpers';
 import { PackageType, NpmClientType } from '../types';
 
 const gitPrefix = 'git+';
 const filePrefix = 'file:';
+const pathPrefixes = ['/', './', '../', '.\\', '..\\', '~/', '~\\', filePrefix];
 
 function isProjectReference(name: string) {
   const target = resolve(name, 'package.json');
   return checkExists(target);
 }
 
-export function detectPnpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'pnpm-lock.yaml'), constants.F_OK, (noPnpmLock) => {
-      res(!noPnpmLock);
-    });
-  });
+function resolveAbsPath(basePath: string, fullName: string) {
+  const prefixed = fullName.startsWith(filePrefix);
+  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
+  return resolve(basePath, relPath);
 }
 
-export function detectNpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'package-lock.json'), constants.F_OK, (noPackageLock) => {
-      res(!noPackageLock);
-    });
-  });
-}
+async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClientType]> {
+  let previous = root;
 
-export async function detectYarn(root: string) {
-  return !!(await findFile(root, 'yarn.lock'));
-}
+  do {
+    if (await checkExists(resolve(root, 'lerna.json'))) {
+      return [root, 'lerna'];
+    }
 
-export async function getLernaConfigPath(root: string) {
-  log('generalDebug_0003', 'Trying to get the configuration file for Lerna ...');
-  const file = await findFile(root, 'lerna.json');
+    if (await checkExists(resolve(root, 'rush.json'))) {
+      return [root, 'rush'];
+    }
 
-  if (file) {
-    log('generalDebug_0003', `Found Lerna config in "${file}".`);
-    return file;
-  }
+    if (await checkExists(resolve(root, 'pnpm-workspace.yaml'))) {
+      return [root, 'pnpm'];
+    }
 
-  return undefined;
-}
+    const packageJson = await readJson(root, 'package.json');
 
-export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
-  const file = await getLernaConfigPath(root);
+    if (Array.isArray(packageJson?.workspaces)) {
+      if (await checkExists(resolve(root, 'yarn.lock'))) {
+        return [root, 'yarn'];
+      }
 
-  if (file) {
-    try {
-      return require(file).npmClient;
-    } catch (err) {
-      log('generalError_0002', `Could not read lerna.json: ${err}.`);
+      return [root, 'npm'];
     }
-  }
 
-  return undefined;
+    previous = root;
+    root = dirname(root);
+  } while (root !== previous);
+
+  return [];
 }
 
 /**
@@ -69,36 +64,45 @@ export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
  */
 export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClientType> {
   if (!selected || !clientTypeKeys.includes(selected)) {
-    log('generalDebug_0003', 'No npm client selected. Checking for lock files ...');
-    const [hasNpm, hasYarn, hasPnpm] = await Promise.all([detectNpm(root), detectYarn(root), detectPnpm(root)]);
-    const found = +hasNpm + +hasYarn + +hasPnpm;
-    log('generalDebug_0003', `Results of the lock file check: npm = ${hasNpm}, Yarn = ${hasYarn}, Pnpm = ${hasPnpm}`);
+    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+
+    const searchedClients = await detectClients(root);
+    const foundClients = searchedClients.filter((m) => m.result);
+
+    log(
+      'generalDebug_0003',
+      `Results of the lock file check: ${searchedClients.map((m) => `${m.client}=${m.result}`).join(', ')}`,
+    );
+
     const defaultClient = config.npmClient;
 
-    if (found !== 1) {
-      const lernaClient = await getLernaNpmClient(root);
+    if (foundClients.length > 1) {
+      const wrapperClient = foundClients.find((m) => isWrapperClient(m.client));
 
-      if (clientTypeKeys.includes(lernaClient)) {
-        log('generalDebug_0003', `Found valid npm client via Lerna: ${lernaClient}.`);
-        return lernaClient;
+      if (wrapperClient) {
+        const { client } = wrapperClient;
+        log('generalDebug_0003', `Found valid wrapper client via lock or config file: "${client}".`);
       }
-    } else if (hasNpm) {
-      log('generalDebug_0003', `Found valid npm client via lockfile.`);
-      return 'npm';
-    } else if (hasYarn) {
-      log('generalDebug_0003', `Found valid Yarn client via lockfile.`);
-      return 'yarn';
-    } else if (hasPnpm) {
-      log('generalDebug_0003', `Found valid pnpm client via lockfile.`);
-      return 'pnpm';
+    }
+
+    if (foundClients.length > 0) {
+      const { client } = foundClients[0];
+
+      if (foundClients.length > 1) {
+        const clientStr = `"${foundClients.map((m) => m.client).join('", "')}"`;
+        log('generalWarning_0001', `Found multiple clients via their lock or config files: ${clientStr}.`);
+      }
+
+      log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+      return client;
     }
 
     if (clientTypeKeys.includes(defaultClient)) {
-      log('generalDebug_0003', `Found valid Pnpm client the default client: "${defaultClient}".`);
+      log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
       return defaultClient;
     }
 
-    log('generalDebug_0003', 'Using the default npm client.');
+    log('generalDebug_0003', 'Using the default "npm" client.');
     return 'npm';
   }
 
@@ -106,103 +110,66 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
-  const c = require(`./clients/npm`);
-  const newRoot = await detectMonorepoRoot(root);
+  const [monorepoRoot, client] = await detectMonorepoRoot(root);
 
-  if (newRoot) {
-    const details = await c.listPackage(refName, newRoot);
-    return details?.dependencies?.[refName]?.extraneous ?? false;
+  if (monorepoRoot) {
+    const c = clients[client];
+    return await c.isProject(monorepoRoot, refName);
   }
 
   return false;
 }
 
-export async function detectMonorepoRoot(root: string): Promise<string> {
-  const file = await getLernaConfigPath(root);
-
-  if (file !== undefined) {
-    return dirname(file);
-  }
-
-  let previous = root;
-
-  do {
-    const packageJson = await readJson(root, 'package.json');
-
-    if (Array.isArray(packageJson?.workspaces)) {
-      return root;
-    }
-
-    previous = root;
-    root = dirname(root);
-  } while (root !== previous);
-
-  return undefined;
+export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
+  const { installDependencies } = clients[client];
+  return installDependencies(target);
 }
 
-export type MonorepoKind = 'none' | 'lerna' | 'yarn';
-
-export async function detectMonorepo(root: string): Promise<MonorepoKind> {
-  const newRoot = await detectMonorepoRoot(root);
-
-  if (newRoot) {
-    const file = await getLernaConfigPath(newRoot);
-
-    if (file !== undefined) {
-      return 'lerna';
-    }
-
-    const packageJson = await readJson(newRoot, 'package.json');
-
-    if (Array.isArray(packageJson?.workspaces)) {
-      return 'yarn';
-    }
-  }
-
-  return 'none';
-}
-
-export function bootstrapMonorepo(target = '.') {
-  const c = require(`./clients/lerna`);
-  return c.bootstrap(target);
-}
-
-export function installDependencies(client: NpmClientType, target = '.'): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installDependencies(target);
-}
-
-export function installPackage(
+export async function installNpmPackage(
   client: NpmClientType,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installPackage(packageRef, target, ...flags);
+  try {
+    const { installPackage } = clients[client];
+    return await installPackage(packageRef, target, ...flags);
+  } catch (ex) {
+    log(
+      'generalError_0002',
+      `Could not install the package "${packageRef}" using ${client}. Make sure ${client} is correctly installed and accessible: ${ex}`,
+    );
+    throw ex;
+  }
+}
+
+export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
+  const { initProject } = clients[client];
+  return initProject(projectName, target);
 }
 
-export function publishPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.publishPackage(target, file, ...flags);
+export function publishNpmPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
+  const { publishPackage } = clients.npm;
+  return publishPackage(target, file, ...flags);
 }
 
-export function createPackage(target = '.'): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.createPackage(target);
+export function createNpmPackage(target = '.'): Promise<string> {
+  const { createPackage } = clients.npm;
+  return createPackage(target);
 }
 
-export function findTarball(packageRef: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findTarball(packageRef);
+export function findNpmTarball(packageRef: string): Promise<string> {
+  const { findTarball } = clients.npm;
+  return findTarball(packageRef);
 }
 
 export function findSpecificVersion(packageName: string, version: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findSpecificVersion(packageName, version);
+  const { findSpecificVersion } = clients.npm;
+  return findSpecificVersion(packageName, version);
 }
 
 export function findLatestVersion(packageName: string) {
+  const { findSpecificVersion } = clients.npm;
   return findSpecificVersion(packageName, 'latest');
 }
 
@@ -210,7 +177,7 @@ export function isLocalPackage(baseDir: string, fullName: string) {
   log('generalDebug_0003', 'Checking if its a local package ...');
 
   if (fullName) {
-    if (/^[\.\/\~]/.test(fullName)) {
+    if (pathPrefixes.some((prefix) => fullName.startsWith(prefix))) {
       log('generalDebug_0003', 'Found a local package by name.');
       return true;
     } else if (fullName.endsWith('.tgz')) {
@@ -249,9 +216,7 @@ export function makeGitUrl(fullName: string) {
 }
 
 export function makeFilePath(basePath: string, fullName: string) {
-  const prefixed = fullName.startsWith(filePrefix);
-  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
-  const absPath = resolve(basePath, relPath);
+  const absPath = resolveAbsPath(basePath, fullName);
   return `${filePrefix}${absPath}`;
 }
 
@@ -275,7 +240,7 @@ export async function dissectPackageName(
     const gitUrl = makeGitUrl(fullName);
     return [gitUrl, 'latest', false, 'git'];
   } else if (isLocalPackage(baseDir, fullName)) {
-    const fullPath = resolve(baseDir, fullName);
+    const fullPath = resolveAbsPath(baseDir, fullName);
     const exists = await checkExists(fullPath);
 
     if (!exists) {
@@ -418,7 +383,8 @@ export function isLinkedPackage(name: string, type: PackageType, hadVersion: boo
 
 export function combinePackageRef(name: string, version: string, type: PackageType) {
   if (type === 'registry') {
-    return `${name}@${version || 'latest'}`;
+    const tag = version || 'latest';
+    return `${name}@${tag}`;
   }
 
   return name;
@@ -472,19 +438,22 @@ export function getPackageVersion(
   }
 }
 
-function getExternalsFrom(packageName: string): Array<string> | undefined {
+function getExternalsFrom(root: string, packageName: string): Array<string> | undefined {
   try {
-    return require(`${packageName}/package.json`).sharedDependencies;
+    const target = require.resolve(`${packageName}/package.json`, {
+      paths: [root],
+    });
+    return require(target).sharedDependencies;
   } catch (err) {
     log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
     return undefined;
   }
 }
 
-function getCoreExternals(dependencies: Record<string, string>): Array<string> {
+function getCoreExternals(root: string, dependencies: Record<string, string>): Array<string> {
   for (const frameworkLib of frameworkLibs) {
     if (dependencies[frameworkLib]) {
-      const deps = getExternalsFrom(frameworkLib);
+      const deps = getExternalsFrom(root, frameworkLib);
 
       if (deps) {
         return deps;
@@ -497,24 +466,23 @@ function getCoreExternals(dependencies: Record<string, string>): Array<string> {
 }
 
 export function makePiletExternals(
+  root: string,
   dependencies: Record<string, string>,
   externals: Array<string>,
   fromEmulator: boolean,
   piralInfo: any,
-) {
+): Array<string> {
   if (fromEmulator) {
-    const { sharedDependencies = makeExternals(dependencies, externals, true) } = piralInfo;
+    const { sharedDependencies = mergeExternals(externals, legacyCoreExternals) } = piralInfo;
     return sharedDependencies;
   } else {
-    return makeExternals(dependencies, externals);
+    return makeExternals(root, dependencies, externals);
   }
 }
 
-export function makeExternals(dependencies: Record<string, string>, externals?: Array<string>, legacy = false) {
-  const coreExternals = legacy ? legacyCoreExternals : getCoreExternals(dependencies);
-
-  if (externals && Array.isArray(externals)) {
-    const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
+export function mergeExternals(customExternals?: Array<string>, coreExternals: Array<string> = []) {
+  if (customExternals && Array.isArray(customExternals)) {
+    const [include, exclude] = customExternals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {
         if (typeof curr === 'string') {
           if (curr.startsWith('!')) {
@@ -534,3 +502,8 @@ export function makeExternals(dependencies: Record<string, string>, externals?:
 
   return coreExternals;
 }
+
+export function makeExternals(root: string, dependencies: Record<string, string>, externals?: Array<string>) {
+  const coreExternals = getCoreExternals(root, dependencies);
+  return mergeExternals(externals, coreExternals);
+}

package/src/common/pack.test.ts

@@ -13,7 +13,7 @@ jest.mock('./io', () => ({
 }));
 
 jest.mock('./npm', () => ({
-  createPackage: (target?: string) => {
+  createNpmPackage: (target?: string) => {
     return Promise.resolve(target);
   },
 }));

package/src/common/pack.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from 'path';
 import { log, progress, fail } from './log';
 import { readJson, move } from './io';
-import { createPackage } from './npm';
+import { createNpmPackage } from './npm';
 import { ForceOverwrite } from './enums';
 
 async function getFile(root: string, name: string, dest: string) {
@@ -38,7 +38,7 @@ export async function createPiletPackage(baseDir: string, source: string, target
 
   progress(`Packing pilet in ${dest} ...`);
   log('generalDebug_0003', 'Creating package ...');
-  await createPackage(root);
+  await createNpmPackage(root);
   log('generalDebug_0003', 'Successfully created package.');
   const name = `${pckg.name}-${pckg.version}.tgz`.replace(/@/g, '').replace(/\//g, '-');
   log('generalDebug_0003', `Assumed package name "${name}".`);

package/src/common/package.ts

@@ -13,7 +13,7 @@ import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath } from './npm';
 import { makePiletExternals, makeExternals, findPackageRoot } from './npm';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -149,7 +149,7 @@ function findPackage(pck: string | Array<string>, baseDir: string) {
   return undefined;
 }
 
-export function readPiralPackage(root: string, name: string) {
+export function readPiralPackage(root: string, name: string): Promise<PackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
   return readJson(path, 'package.json');
@@ -318,10 +318,19 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
   return typeof item === 'object';
 }
 
+function tryFindPackageVersion(packageName: string): string {
+  try {
+    const { version } = require(`${packageName}/package.json`);
+    return version;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
@@ -341,7 +350,7 @@ export async function copyPiralFiles(
   await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
-export function getPiletsInfo(piralInfo: any): PiletsInfo {
+export function getPiletsInfo(piralInfo: Partial<PackageData>): PiletsInfo {
   const {
     files = [],
     scripts = {},
@@ -450,7 +459,7 @@ export async function retrieveExternals(root: string, packageInfo: any) {
       ...packageInfo.dependencies,
     };
     const deps = packageInfo.pilets?.externals;
-    return makeExternals(allDeps, deps);
+    return makeExternals(root, allDeps, deps);
   }
 
   return sharedDependencies.map((m) => m.name);
@@ -469,9 +478,9 @@ export async function retrievePiletsInfo(entryFile: string) {
     fail('packageJsonMissing_0074');
   }
 
+  const root = dirname(packageJson);
   const packageInfo = require(packageJson);
   const info = getPiletsInfo(packageInfo);
-  const root = dirname(packageJson);
   const externals = await retrieveExternals(root, packageInfo);
 
   return {
@@ -500,7 +509,7 @@ export async function patchPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -524,7 +533,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
-  const allExternals = makePiletExternals(piralDependencies, externals, fromEmulator, piralInfo);
+  const allExternals = makePiletExternals(root, piralDependencies, externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);
@@ -548,7 +557,7 @@ export async function patchPiletPackage(
       return deps;
     }, {}),
     ...allExternals.filter(isValidDependency).reduce((deps, name) => {
-      const version = piralDependencies[name];
+      const version = piralDependencies[name] || tryFindPackageVersion(name);
 
       if (version || newInfo) {
         // set only if we have an explicit version or we are in the scaffolding case
@@ -585,7 +594,7 @@ export async function patchPiletPackage(
 /**
  * Returns true if its an emulator package, otherwise it has to be a "raw" app shell.
  */
-export function checkAppShellPackage(appPackage: any) {
+export function checkAppShellPackage(appPackage: PackageData) {
   const { piralCLI = { generated: false, version: cliVersion } } = appPackage;
 
   if (piralCLI.generated) {

package/src/common/port.ts

@@ -1,6 +1,16 @@
 import { log } from './log';
 import { getPort } from '../external';
 
+export async function getAvailablePort(defaultPort: number) {
+  const selectedPort = await getFreePort(defaultPort);
+
+  if (selectedPort !== defaultPort) {
+    log('portNotFree_0047', selectedPort, defaultPort);
+  }
+
+  return selectedPort;
+}
+
 export async function getFreePort(preferred?: number) {
   log('generalDebug_0003', `Looking for a free port. Preferred port: ${preferred}`);
   const port = await getPort(preferred && { port: preferred });

package/src/common/scaffold.ts

@@ -1,5 +1,5 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
-import { installPackage } from './clients/npm';
+import { installNpmPackage } from './npm';
 import { ForceOverwrite, SourceLanguage } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { cliVersion, isWindows } from './info';
@@ -37,7 +37,11 @@ async function getTemplateFiles(
   if (templatePackageName.startsWith('.')) {
     templatePackageName = resolve(process.cwd(), templatePackageName);
   } else {
-    await installPackage(templatePackageName, __dirname, '--registry', registry);
+    if (templatePackageName.indexOf('@', 1) === -1) {
+      templatePackageName = `${templatePackageName}@latest`;
+    }
+
+    await installNpmPackage('npm', templatePackageName, __dirname, '--registry', registry);
   }
 
   const templateRunner = getTemplatePackage(templatePackageName);

package/src/common/version.ts

@@ -16,15 +16,15 @@ function indexOrEnd(str: string, q: string) {
 }
 
 function splitVersion(v: string) {
-  var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-  var patchIndex = indexOrEnd(c, '-');
-  var arr = c.substring(0, patchIndex).split('.');
+  const c = v.replace(/^v/, '').replace(/\+.*$/, '');
+  const patchIndex = indexOrEnd(c, '-');
+  const arr = c.substring(0, patchIndex).split('.');
   arr.push(c.substring(patchIndex + 1));
   return arr;
 }
 
 function parseSegment(v: string) {
-  var n = parseInt(v, 10);
+  const n = parseInt(v, 10);
   return isNaN(n) ? v : n;
 }
 

package/src/external/index.ts

@@ -1,6 +1,7 @@
 import logger = require('@parcel/logger');
 import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
+import jju = require('jju');
 import glob = require('glob');
 import tar = require('tar');
 import FormData = require('form-data');
@@ -10,4 +11,4 @@ import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open };
+export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open, jju };

package/src/helpers.test.ts

@@ -1,4 +1,4 @@
-import { keyOfForceOverwrite, keyOfPiletLanguage, valueOfForceOverwrite, valueOfPiletLanguage } from './helpers';
+import { keyOfForceOverwrite, keyOfSourceLanguage, valueOfForceOverwrite, valueOfSourceLanguage } from './helpers';
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 
 describe('Piral CLI Command Helpers Module', () => {
@@ -13,12 +13,12 @@ describe('Piral CLI Command Helpers Module', () => {
   });
 
   it('correct value of keyOfPiletLanguage results in same key', () => {
-    const result = keyOfPiletLanguage(SourceLanguage.ts);
+    const result = keyOfSourceLanguage(SourceLanguage.ts);
     expect(result).toBe('ts');
   });
 
   it('incorrect value of keyOfPiletLanguage results in key for TS', () => {
-    const result = keyOfPiletLanguage(5);
+    const result = keyOfSourceLanguage(5);
     expect(result).toBe('ts');
   });
 
@@ -33,12 +33,12 @@ describe('Piral CLI Command Helpers Module', () => {
   });
 
   it('correct key of valueOfPiletLanguage results in same value', () => {
-    const result = valueOfPiletLanguage('ts');
+    const result = valueOfSourceLanguage('ts');
     expect(result).toBe(SourceLanguage.ts);
   });
 
   it('incorrect key of valueOfPiletLanguage results in value for TS', () => {
-    const result = valueOfPiletLanguage('foo');
+    const result = valueOfSourceLanguage('foo');
     expect(result).toBe(SourceLanguage.ts);
   });
 });