piral-cli 0.15.0-alpha.3564 → 0.15.0-alpha.3662

package/src/apps/debug-piral.ts

@@ -14,6 +14,7 @@ import {
   log,
   config,
   normalizePublicUrl,
+  logDone,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -151,11 +152,15 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     bundlerName,
   );
 
+  bundler.ready().then(() => logDone(`Ready!`));
+
   bundler.on((args) => {
     hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, name, bundler });
   });
 
+  const { piral: piralInjector, ...otherInjectors } = krasConfig.injectors;
   const injectorConfig = {
+    ...piralInjector,
     active: true,
     handle: ['/'],
     publicUrl,
@@ -163,7 +168,7 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   };
 
   krasConfig.map['/'] = '';
-  krasConfig.injectors = reorderInjectors(injectorName, injectorConfig, krasConfig.injectors);
+  krasConfig.injectors = reorderInjectors(injectorName, injectorConfig, otherInjectors);
 
   log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
 

package/src/common/http.ts

@@ -4,7 +4,6 @@ import { Stream } from 'stream';
 import { platform, tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
-import { computeHash } from './hash';
 import { axios, FormData } from '../external';
 
 const os = platform();
@@ -40,18 +39,6 @@ function streamToFile(source: Stream, target: string) {
   });
 }
 
-export function getHashFromUrl(target: string): Promise<string> {
-  return axios.default
-    .get<Buffer>(target, {
-      responseType: 'arraybuffer',
-      headers: standardHeaders,
-    })
-    .then((res) => {
-      log('generalDebug_0003', `Received the contents from "${target}" (status: ${res.status}).`);
-      return computeHash(res.data);
-    });
-}
-
 export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
   return axios.default

package/src/common/importmap.ts

@@ -0,0 +1,153 @@
+import { resolve, dirname } from 'path';
+import { log, fail } from './log';
+import { satisfies, validate } from './version';
+import { computeHash } from './hash';
+import { getHash, readJson, findFile, checkExists, checkIsDirectory } from './io';
+import { SharedDependency } from '../types';
+
+interface Importmap {
+  imports: Record<string, string>;
+}
+
+function tryResolve(baseDir: string, name: string) {
+  try {
+    return require.resolve(name, {
+      paths: [baseDir],
+    });
+  } catch (ex) {
+    log('generalDebug_0003', `Could not resolve the package "${name}" in "${baseDir}": ${ex}`);
+    return undefined;
+  }
+}
+
+function getDependencyDetails(depName: string): [assetName: string, identifier: string, versionSpec: string] {
+  const sep = depName.indexOf('@', 1);
+  const version = sep > 0 ? depName.substring(sep + 1) : '';
+  const id = sep > 0 ? depName.substring(0, sep) : depName;
+  const assetName = (id.startsWith('@') ? id.substring(1) : id).replace(/[\/\.]/g, '-').replace(/(\-)+/, '-');
+  return [assetName, id, version];
+}
+
+function getLocalDependencyVersion(
+  packageJson: string,
+  depName: string,
+  versionSpec: string,
+): [offeredVersion: string, requiredVersion: string] {
+  const details = require(packageJson);
+
+  if (versionSpec) {
+    if (!validate(versionSpec)) {
+      fail('importMapVersionSpecInvalid_0026', depName);
+    }
+
+    if (!satisfies(details.version, versionSpec)) {
+      fail('importMapVersionSpecNotSatisfied_0025', depName, details.version);
+    }
+
+    return [details.version, versionSpec];
+  }
+
+  return [details.version, details.version];
+}
+
+async function resolveImportmap(dir: string, importmap: Importmap) {
+  const dependencies: Array<SharedDependency> = [];
+  const sharedImports = importmap?.imports;
+
+  if (typeof sharedImports === 'object' && sharedImports) {
+    for (const depName of Object.keys(sharedImports)) {
+      const url = sharedImports[depName];
+      const [assetName, identifier, versionSpec] = getDependencyDetails(depName);
+
+      if (typeof url !== 'string') {
+        log('generalInfo_0000', `The value of "${depName}" in the importmap is not a string and will be ignored.`);
+      } else if (/^https?:\/\//.test(url)) {
+        const hash = computeHash(url);
+
+        dependencies.push({
+          id: `${identifier}@${hash}`,
+          requireId: `${identifier}@${hash}`,
+          entry: url,
+          name: identifier,
+          ref: url,
+          type: 'remote',
+        });
+      } else if (url === identifier) {
+        const entry = tryResolve(dir, identifier);
+
+        if (entry) {
+          const packageJson = await findFile(dirname(entry), 'package.json');
+          const [version, requireVersion] = getLocalDependencyVersion(packageJson, depName, versionSpec);
+
+          dependencies.push({
+            id: `${identifier}@${version}`,
+            requireId: `${identifier}@${requireVersion}`,
+            entry,
+            name: identifier,
+            ref: `${assetName}.js`,
+            type: 'local',
+          });
+        } else {
+          fail('importMapReferenceNotFound_0027', dir, url);
+        }
+      } else {
+        const entry = resolve(dir, url);
+        const exists = await checkExists(entry);
+
+        if (exists) {
+          const isDirectory = await checkIsDirectory(entry);
+          const packageJson = isDirectory ? resolve(entry, 'package.json') : await findFile(dirname(entry), 'package.json');
+          const packageJsonExists = await checkExists(packageJson);
+
+          if (packageJsonExists) {
+            const [version, requireVersion] = getLocalDependencyVersion(packageJson, depName, versionSpec);
+
+            dependencies.push({
+              id: `${identifier}@${version}`,
+              requireId: `${identifier}@${requireVersion}`,
+              entry: isDirectory ? tryResolve(dir, entry) : entry,
+              name: identifier,
+              ref: `${assetName}.js`,
+              type: 'local',
+            });
+          } else if (isDirectory) {
+            fail('importMapReferenceNotFound_0027', entry, 'package.json');
+          } else {
+            const hash = await getHash(entry);
+
+            dependencies.push({
+              id: `${identifier}@${hash}`,
+              requireId: `${identifier}@${hash}`,
+              entry,
+              name: identifier,
+              ref: `${assetName}.js`,
+              type: 'local',
+            });
+          }
+        } else {
+          fail('importMapReferenceNotFound_0027', dir, url);
+        }
+      }
+    }
+  }
+
+  return dependencies;
+}
+
+export async function readImportmap(dir: string, packageDetails: any) {
+  const importmap = packageDetails.importmap;
+
+  if (typeof importmap === 'string') {
+    const notFound = {};
+    const content = await readJson(dir, importmap, notFound);
+
+    if (content === notFound) {
+      fail('importMapFileNotFound_0028', dir, importmap);
+    }
+
+    const baseDir = dirname(resolve(dir, importmap));
+    return resolveImportmap(baseDir, content);
+  }
+
+  return resolveImportmap(dir, importmap);
+}

package/src/common/index.ts

@@ -10,6 +10,7 @@ export * from './emoji';
 export * from './envs';
 export * from './hash';
 export * from './http';
+export * from './importmap';
 export * from './info';
 export * from './injectors';
 export * from './io';

package/src/common/package.test.ts

@@ -16,8 +16,8 @@ describe('CLI package module', () => {
 
   it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
     const dir = process.cwd();
-    const version = findPackageRoot('parcel-bundler', dir);
-    expect(version).toBe(resolve(dir, 'node_modules', 'parcel-bundler', 'package.json'));
+    const version = findPackageRoot('webpack', dir);
+    expect(version).toBe(resolve(dir, 'node_modules', 'webpack', 'package.json'));
   });
 
   it('findPackageRoot returns undefined for invalid package', () => {

package/src/common/package.ts

@@ -6,13 +6,13 @@ import { getDependencies, getDevDependencies } from './language';
 import { SourceLanguage, ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
-import { getHashFromUrl } from './http';
 import { applyTemplate } from './template';
+import { readImportmap } from './importmap';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, SharedDependency } from '../types';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
 
 function getDependencyVersion(
   name: string,
@@ -574,108 +574,6 @@ export function checkAppShellPackage(appPackage: any) {
   return false;
 }
 
-function tryResolve(baseDir: string, name: string) {
-  try {
-    return require.resolve(name, {
-      paths: [baseDir],
-    });
-  } catch (ex) {
-    log('generalDebug_0003', `Could not resolve the package "${name}" in "${baseDir}": ${ex}`);
-    return undefined;
-  }
-}
-
-interface Importmap {
-  imports: Record<string, string>;
-}
-
-function normalizeDepName(s: string) {
-  return (s.startsWith('@') ? s.substring(1) : s).replace(/[\/\.]/g, '-').replace(/(\-)+/, '-');
-}
-
-async function resolveImportmap(dir: string, importmap: Importmap) {
-  const dependencies: Array<SharedDependency> = [];
-  const sharedImports = importmap?.imports;
-
-  if (typeof sharedImports === 'object' && sharedImports) {
-    for (const depName of Object.keys(sharedImports)) {
-      const url = sharedImports[depName];
-      const assetName = normalizeDepName(depName);
-
-      if (typeof url !== 'string') {
-      } else if (/^https?:\/\//.test(url)) {
-        const hash = await getHashFromUrl(url);
-
-        dependencies.push({
-          id: `${depName}@${hash}`,
-          entry: url,
-          name: depName,
-          ref: url,
-          type: 'remote',
-        });
-      } else if (url === depName) {
-        const entry = tryResolve(dir, depName);
-
-        if (entry) {
-          const packageJson = await findFile(dirname(entry), 'package.json');
-          const details = require(packageJson);
-
-          dependencies.push({
-            id: `${depName}@${details.version}`,
-            entry,
-            ref: `${assetName}.js`,
-            name: depName,
-            type: 'local',
-          });
-        }
-      } else {
-        const entry = resolve(dir, url);
-        const exists = await checkExists(entry);
-
-        if (exists) {
-          const packageJson = await findFile(dirname(entry), 'package.json');
-
-          if (packageJson) {
-            const details = require(packageJson);
-
-            dependencies.push({
-              id: `${depName}@${details.version}`,
-              entry,
-              name: depName,
-              ref: `${assetName}.js`,
-              type: 'local',
-            });
-          } else {
-            const hash = await getHash(entry);
-
-            dependencies.push({
-              id: `${depName}@${hash}`,
-              entry,
-              name: depName,
-              ref: `${assetName}.js`,
-              type: 'local',
-            });
-          }
-        }
-      }
-    }
-  }
-
-  return dependencies;
-}
-
-export async function readImportmap(dir: string, packageDetails: any) {
-  const importmap = packageDetails.importmap;
-
-  if (typeof importmap === 'string') {
-    const content = await readJson(dir, importmap);
-    const baseDir = dirname(resolve(dir, importmap));
-    return resolveImportmap(baseDir, content);
-  }
-
-  return resolveImportmap(dir, importmap);
-}
-
 export async function retrievePiletData(target: string, app?: string) {
   const packageJson = await findFile(target, 'package.json');
 

package/src/common/spec.ts

@@ -46,6 +46,7 @@ export function getPiletSpecMeta(target: string, basePath: string) {
         dependencies: getDependencies(plainDependencies, basePath),
       };
     } else {
+      // uses no arguments
       return {
         spec: 'v0',
         hash: computeHash(content),

package/src/common/version.test.ts

@@ -0,0 +1,233 @@
+import { satisfies, validate } from './version';
+
+describe('semver check module', () => {
+  it('specific publish version is valid', () => {
+    const result = validate('1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('shortened publish version is valid', () => {
+    const result = validate('1.2');
+    expect(result).toBeTruthy();
+  });
+
+  it('some hash is invalid', () => {
+    const result = validate('fabcde');
+    expect(result).toBeFalsy();
+  });
+
+  it('some longer hash is invalid', () => {
+    const result = validate('123fabdef0012');
+    expect(result).toBeFalsy();
+  });
+
+  it('major publish version is valid', () => {
+    const result = validate('1');
+    expect(result).toBeTruthy();
+  });
+
+  it('any publish version is valid', () => {
+    const result = validate('1.2.x');
+    expect(result).toBeTruthy();
+  });
+
+  it('specific preview version is valid', () => {
+    const result = validate('1.2.3-pre.123');
+    expect(result).toBeTruthy();
+  });
+
+  it('caret version is specifier valid', () => {
+    const result = validate('^1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('tilde version is specifier valid', () => {
+    const result = validate('~1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater version is specifier valid', () => {
+    const result = validate('>1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater equals version is specifier valid', () => {
+    const result = validate('>=1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater equals with x version is specifier valid', () => {
+    const result = validate('>=1.x');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match', () => {
+    const result = satisfies('1.2.3', '1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy exact version mismatch greater', () => {
+    const result = satisfies('1.2.3', '1.2.4');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch smaller', () => {
+    const result = satisfies('1.2.3', '1.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with caret patch', () => {
+    const result = satisfies('1.2.3', '^1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret minor', () => {
+    const result = satisfies('1.3.0', '^1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact', () => {
+    const result = satisfies('1.3.0', '^1.3.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact with dropped number', () => {
+    const result = satisfies('1.3.0', '^1.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact with dropped numbers', () => {
+    const result = satisfies('1', '^1');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint with caret major', () => {
+    const result = satisfies('2.0.0', '^1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with tilde patch', () => {
+    const result = satisfies('1.2.3', '~1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint with tilde minor', () => {
+    const result = satisfies('1.3.0', '~1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy constraint with tilde patch greater', () => {
+    const result = satisfies('1.3.0', '~1.3.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with tilde patch lighter', () => {
+    const result = satisfies('1.3.3', '~1.3.2');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with x patch', () => {
+    const result = satisfies('1.2.3', '1.x.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint x minor', () => {
+    const result = satisfies('1.3.0', '1.2.x');
+    expect(result).toBeFalsy();
+  });
+
+  it('satsfies greater than matching', () => {
+    const result = satisfies('1.3.0', '>=1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satsfies less than matching', () => {
+    const result = satisfies('1.3.0', '<=1.3.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy only greater than non-matching', () => {
+    const result = satisfies('1.3.0', '>1.3.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy greater than non-matching', () => {
+    const result = satisfies('1.3.0', '>=1.3.1');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<=1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<1.3.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<=1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies exact version match with previews', () => {
+    const result = satisfies('1.2.3-pre.5', '1.2.3-pre.5');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match with dropped number', () => {
+    const result = satisfies('1.0', '1');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match with dropped numbers', () => {
+    const result = satisfies('1', '1.0.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy exact version mismatch preview', () => {
+    const result = satisfies('1.2.4-pre.5', '1.2.4-pre.6');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview version offered', () => {
+    const result = satisfies('1.2.4-beta', '1.2.4-beta.5');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview version demanded', () => {
+    const result = satisfies('1.2.4-beta.5', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview higher', () => {
+    const result = satisfies('1.2.4-gamma', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview smaller', () => {
+    const result = satisfies('1.2.4-alpha', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact and preview mismatch', () => {
+    const result = satisfies('1.2.4-pre.5', '1.2.4');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies just an x', () => {
+    const result = satisfies('1.2.3', 'x');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies just a *', () => {
+    const result = satisfies('1.2.3', '*');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies just a >=0', () => {
+    const result = satisfies('1.2.3', '>=0');
+    expect(result).toBeTruthy();
+  });
+});