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

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.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/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();
+  });
+});

package/src/common/version.ts

@@ -0,0 +1,142 @@
+const semver =
+  /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+
+const acceptsAll = ['*', 'x', '>=0'];
+
+const operatorResMap: Record<string, [number, number?]> = {
+  '>': [1],
+  '>=': [0, 1],
+  '=': [0],
+  '<=': [-1, 0],
+  '<': [-1],
+};
+
+function indexOrEnd(str: string, q: string) {
+  return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
+}
+
+function splitVersion(v: string) {
+  var c = v.replace(/^v/, '').replace(/\+.*$/, '');
+  var patchIndex = indexOrEnd(c, '-');
+  var arr = c.substring(0, patchIndex).split('.');
+  arr.push(c.substring(patchIndex + 1));
+  return arr;
+}
+
+function parseSegment(v: string) {
+  var n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+}
+
+function validateAndParse(v: string) {
+  const match = v.match(semver);
+  match.shift();
+  return match;
+}
+
+function compareStrings(a: string, b: string) {
+  const ap = parseSegment(a);
+  const bp = parseSegment(b);
+
+  if (ap > bp) {
+    return 1;
+  } else if (ap < bp) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+function compareSegments(a: [string, string], b: [string, string]) {
+  for (let i = 0; i < 2; i++) {
+    const r = compareStrings(a[i] || '0', b[i] || '0');
+
+    if (r !== 0) {
+      return r;
+    }
+  }
+
+  return 0;
+}
+
+function compareVersions(v1: string, v2: string) {
+  const s1 = splitVersion(v1);
+  const s2 = splitVersion(v2);
+  const len = Math.max(s1.length - 1, s2.length - 1);
+
+  for (let i = 0; i < len; i++) {
+    const n1 = parseInt(s1[i] || '0', 10);
+    const n2 = parseInt(s2[i] || '0', 10);
+
+    if (n1 > n2) {
+      return 1;
+    } else if (n2 > n1) {
+      return -1;
+    }
+  }
+
+  const sp1 = s1[s1.length - 1];
+  const sp2 = s2[s2.length - 1];
+
+  if (sp1 && sp2) {
+    const p1 = sp1.split('.').map(parseSegment);
+    const p2 = sp2.split('.').map(parseSegment);
+    const len = Math.max(p1.length, p2.length);
+
+    for (let i = 0; i < len; i++) {
+      if (p1[i] === undefined || (typeof p2[i] === 'string' && typeof p1[i] === 'number')) {
+        return -1;
+      } else if (p2[i] === undefined || (typeof p1[i] === 'string' && typeof p2[i] === 'number')) {
+        return 1;
+      } else if (p1[i] > p2[i]) {
+        return 1;
+      } else if (p2[i] > p1[i]) {
+        return -1;
+      }
+    }
+  } else if (sp1 || sp2) {
+    return sp1 ? -1 : 1;
+  }
+
+  return 0;
+}
+
+function compare(v1: string, v2: string, operator: string) {
+  // since result of compareVersions can only be -1 or 0 or 1
+  // a simple map can be used to replace switch
+  const res = compareVersions(v1, v2);
+  return operatorResMap[operator].indexOf(res) > -1;
+}
+
+export function validate(version: string) {
+  return acceptsAll.includes(version) || semver.test(version);
+}
+
+export function satisfies(v: string, r: string) {
+  if (!acceptsAll.includes(r)) {
+    // if no range operator then "="
+    const match = r.match(/^([<>=~^]+)/);
+    const op = match ? match[1] : '=';
+
+    // if gt/lt/eq then operator compare
+    if (op !== '^' && op !== '~') {
+      return compare(v, r, op);
+    }
+
+    // else range of either "~" or "^" is assumed
+    const [v1, v2, v3] = validateAndParse(v);
+    const [m1, m2, m3] = validateAndParse(r);
+
+    if (compareStrings(v1, m1) !== 0) {
+      return false;
+    } else if (op === '^') {
+      return compareSegments([v2, v3], [m2, m3]) >= 0;
+    } else if (compareStrings(v2, m2) !== 0) {
+      return false;
+    }
+
+    return compareStrings(v3, m3) >= 0;
+  }
+
+  return true;
+}

package/src/messages.ts

@@ -392,6 +392,205 @@ export function packageVersionInvalid_0024(version: string): QuickMessage {
   return [LogLevels.error, '0024', `The given package version "${version}" is invalid.`];
 }
 
+/**
+ * @kind Error
+ *
+ * @summary
+ * Cannot add the shared dependency since its version constraint is not satisfied.
+ *
+ * @abstract
+ * The importmap definition allows you to define a version specifier separated with
+ * the '@' character. If you write down a version specifier then it has to be
+ * fulfilled already from the local version, otherwise the packaged version can
+ * potentially not be resolved at runtime. This would resolve in a pilet that fails
+ * when running in isolation and most likely fails when running with other pilets.
+ *
+ * @see
+ * - [import-maps specification](https://github.com/WICG/import-maps)
+ *
+ * @example
+ * Check the contents of the available package.json:
+ *
+ * ```sh
+ * cat package.json
+ * ```
+ *
+ * The displayed content should look similar to (i.e., contain an importmap such as):
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "foo@^3.2.1": "foo"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * For the error to occur the specifier (^3.2.1) potentially does not match the version (e.g., if
+ * the version of the dependency is 3.1.2).
+ *
+ * One strategy is to remove the specifier, which will automatically use the exact current version
+ * as specifier:
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "foo": "foo"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The best way, however, is to look at the used version and adjust the specifier to be correct again.
+ * Alternatively, change the used version to satisfy the constraint again.
+ */
+export function importMapVersionSpecNotSatisfied_0025(depName: string, version: string): QuickMessage {
+  return [LogLevels.error, '0025', `The dependency "${depName}" in only available in version "${version}".`];
+}
+
+/**
+ * @kind Error
+ *
+ * @summary
+ * The version spec part of the importmap identifer is invalid.
+ *
+ * @abstract
+ * The importmap definition allows you to define a version specifier separated with
+ * the '@' character. This part has to follow the semver convention and rules.
+ *
+ * Check your specifier via online tools such as "Semver check" to verify it is
+ * valid and follows the semver specification.
+ *
+ * @see
+ * - [Online Checker](https://jubianchi.github.io/semver-check/)
+ *
+ * @example
+ * Check the contents of the available package.json:
+ *
+ * ```sh
+ * cat package.json
+ * ```
+ *
+ * The displayed content should look similar to (i.e., contain an importmap such as):
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "foo@bar": "foo"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * For the error to occur the specifier (bar) is not following the semver specification.
+ *
+ * One way is to remove the version spec, which will resolve to an exact version specifier
+ * and therefore always works:
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "foo": "foo"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The best way, however, is to look at the used version and adjust the specifier to be correct again,
+ * such as "^1.2.3" or "1.x" or "3" etc.
+ */
+export function importMapVersionSpecInvalid_0026(depName: string): QuickMessage {
+  return [LogLevels.error, '0026', `The dependency "${depName}" has an invalid version spec.`];
+}
+
+/**
+ * @kind Error
+ *
+ * @summary
+ * The provided importmap reference could not be resolved.
+ *
+ * @abstract
+ * The importmap consists of keys and values. The keys represent the packages names and optional
+ * version specifiers to demand at runtime. The values represent the entry point or URL to use
+ * when the dependency is not yet loaded.
+ *
+ * In case of a non-URL value the reference has either to be a valid package name or a file path
+ * that leads to either a package or valid JS module. Either way, it needs to exist. If the path
+ * is invalid an error will be emitted.
+ *
+ * @see
+ * - [npm Install](https://docs.npmjs.com/cli/install)
+ *
+ * @example
+ * Check the contents of the available package.json:
+ *
+ * ```sh
+ * cat package.json
+ * ```
+ *
+ * The displayed content should look similar to (i.e., contain an importmap such as):
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "foo@bar": "./node_modules/prect"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Note the potential misspelling. It maybe should have been "./node_modules/preact". In such
+ * cases the reference may not be resolved locally. If everything was written correctly the
+ * node modules are most likely not installed (correctly).
+ */
+export function importMapReferenceNotFound_0027(dir: string, reference: string): QuickMessage {
+  return [LogLevels.error, '0027', `The reference to "${reference}" could not be resolved from "${dir}". Are you sure the file or package exists?`];
+}
+
+/**
+ * @kind Error
+ *
+ * @summary
+ * The provided importmap file could not be found.
+ *
+ * @abstract
+ * The importmap can be referenced in a file from the package.json. If the named
+ * file cannot be found the build process has to be stopped. Make sure that the
+ * file has been specified relative to the package.json where it was referenced
+ * from.
+ *
+ * @see
+ * - [import-maps specification](https://github.com/WICG/import-maps)
+ *
+ * @example
+ * Check the contents of the available package.json:
+ *
+ * ```sh
+ * cat package.json
+ * ```
+ *
+ * The displayed content should look similar to (i.e., contain an importmap such as):
+ *
+ * ```json
+ * {
+ *   "importmap": "./import-map.json"
+ * }
+ * ```
+ *
+ * If the importmap has instead been (re)named "importmap.json" then this will not work.
+ * Likewise, with the reference above the file is expected to be in the same directory
+ * as the package.json. If it is, e.g., in the "src" subfolder you'd should reference it
+ * as "./src/import-map.json" instead.
+ */
+export function importMapFileNotFound_0028(dir: string, file: string): QuickMessage {
+  return [LogLevels.error, '0028', `The importmap "${file}" could not be found at "${dir}".`];
+}
+
 /**
  * @kind Error
  *