piral-cli 0.14.0-pre.2983 → 0.14.0-pre.3074

package/src/common/package.ts

@@ -5,12 +5,13 @@ import { unpackTarball } from './archive';
 import { getDependencies, getDevDependencies } from './language';
 import { SourceLanguage, ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
+import { deepMerge } from './merge';
+import { getHashFromUrl } from './http';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions } from './constants';
-import { getHash, checkIsDirectory, matchFiles, getFileNames } from './io';
+import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makeExternals } from './npm';
-import { deepMerge } from './merge';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, SharedDependency } from '../types';
 
 function getDependencyVersion(
   name: string,
@@ -86,10 +87,15 @@ async function getMatchingFiles(
 }
 
 export function getPiralPath(root: string, name: string) {
-  const path = require.resolve(`${name}/package.json`, {
-    paths: [root],
-  });
-  return dirname(path);
+  try {
+    const path = require.resolve(`${name}/package.json`, {
+      paths: [root],
+    });
+    return dirname(path);
+  } catch (ex) {
+    log('generalDebug_0003', `Could not resolve the Piral path of "${name}" in "${root}": ${ex}.`);
+    fail('invalidPiralReference_0043');
+  }
 }
 
 export function findPackageRoot(pck: string, baseDir: string) {
@@ -528,6 +534,108 @@ 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.substr(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');
 
@@ -548,6 +656,7 @@ export async function retrievePiletData(target: string, app?: string) {
   }
 
   const emulator = checkAppShellPackage(appPackage);
+  const importmap = await readImportmap(root, piletPackage);
 
   return {
     dependencies: piletPackage.dependencies || {},
@@ -555,6 +664,7 @@ export async function retrievePiletData(target: string, app?: string) {
     peerDependencies: piletPackage.peerDependencies || {},
     peerModules: piletPackage.peerModules || [],
     ignored: checkArrayOrUndefined(piletPackage, 'preservedDependencies'),
+    importmap,
     appFile,
     piletPackage,
     appPackage,

package/src/helpers.ts

@@ -1,7 +1,7 @@
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 import { Framework, NpmClientType, PiletSchemaVersion, PiletPublishSource, PiralBuildType } from './types';
 
-export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'none'];
+export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const buildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];

package/src/injectors/pilet.ts

@@ -1,15 +1,17 @@
+import { URL } from 'url';
 import { join } from 'path';
 import { EventEmitter } from 'events';
 import { readFileSync, existsSync, statSync } from 'fs';
 import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
+import { computeHash, computeIntegrity } from '../common/hash';
+import { log } from '../common/log';
 import { axios, mime } from '../external';
 import { Bundler } from '../types';
-import { log } from '../common/log';
 
 interface Pilet {
   bundler: Bundler;
   root: string;
-  requireRef?: string;
+  meta: PiletMetadata;
 }
 
 export interface PiletInjectorConfig extends KrasInjectorConfig {
@@ -24,6 +26,80 @@ interface PiletMetadata {
   [key: string]: unknown;
 }
 
+const checkV1 = /^\/\/\s*@pilet\s+v:1\s*\(([A-Za-z0-9\_\:\-]+)\)/;
+const checkV2 = /^\/\/\s*@pilet\s+v:2\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
+
+function getDependencies(deps: string, basePath: string) {
+  try {
+    const depMap = JSON.parse(deps);
+
+    if (depMap && typeof depMap === 'object') {
+      return Object.keys(depMap).reduce((obj, depName) => {
+        const depUrl = depMap[depName];
+
+        if (typeof depUrl === 'string') {
+          const url = new URL(depUrl, basePath);
+          obj[depName] = url.href;
+        }
+
+        return obj;
+      }, {});
+    }
+  } catch {}
+
+  return {};
+}
+
+function getPiletSpecMeta(target: string, basePath: string) {
+  if (existsSync(target) && statSync(target).isFile()) {
+    const content = readFileSync(target, 'utf8');
+
+    if (checkV1.test(content)) {
+      // uses single argument; requireRef (required)
+      const [, requireRef] = checkV1.exec(content);
+      return {
+        spec: 'v1',
+        requireRef,
+        integrity: computeIntegrity(content),
+      };
+    } else if (checkV2.test(content)) {
+      // uses two arguments; requireRef and dependencies as JSON (required)
+      const [, requireRef, plainDependencies] = checkV2.exec(content);
+      return {
+        spec: 'v2',
+        requireRef,
+        dependencies: getDependencies(plainDependencies, basePath),
+      };
+    } else {
+      return {
+        spec: 'v0',
+        hash: computeHash(content),
+        noCache: true,
+      };
+    }
+  }
+
+  return {};
+}
+
+function fillPiletMeta(pilet: Pilet, basePath: string) {
+  const { root, bundler } = pilet;
+  const def = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+  const file = bundler.bundle.name.replace(/^[\/\\]/, '');
+  const target = join(bundler.bundle.dir, file);
+  const url = new URL(file, basePath);
+  const meta = {
+    name: def.name,
+    version: def.version,
+    link: `${url.href}?updated=${Date.now()}`,
+    custom: def.custom,
+    ...getPiletSpecMeta(target, basePath),
+  };
+
+  pilet.meta = meta;
+  return JSON.stringify(meta);
+}
+
 export default class PiletInjector implements KrasInjector {
   public config: PiletInjectorConfig;
   private piletApi: string;
@@ -49,9 +125,9 @@ export default class PiletInjector implements KrasInjector {
     });
 
     pilets.forEach((p, i) =>
-      p.bundler.on(({ requireRef, version }) => {
-        p.requireRef = version === 'v1' ? requireRef : undefined;
-        const meta = JSON.stringify(this.getMetaOf(i));
+      p.bundler.on(() => {
+        const basePath = `${this.piletApi}/${i}/`;
+        const meta = fillPiletMeta(p, basePath);
 
         for (const id of Object.keys(cbs)) {
           cbs[id](meta);
@@ -77,25 +153,9 @@ export default class PiletInjector implements KrasInjector {
 
   setOptions() {}
 
-  getMetaOf(index: number) {
-    const { api, pilets } = this.config;
-    const { bundler, root, requireRef } = pilets[index];
-    const def = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
-    const file = bundler.bundle.name.replace(/^\//, '');
-    return {
-      name: def.name,
-      version: def.version,
-      link: `${this.piletApi}/${index}/${file}`,
-      hash: bundler.bundle.hash,
-      requireRef,
-      noCache: true,
-      custom: def.custom,
-    };
-  }
-
   async getMeta() {
     const { pilets, feed } = this.config;
-    const localPilets = pilets.map((_, i) => this.getMetaOf(i));
+    const localPilets = pilets.map((pilet) => pilet.meta).filter(Boolean);
     const mergedPilets = this.mergePilets(localPilets, await this.loadRemoteFeed(feed));
 
     if (mergedPilets.length === 1) {

package/src/messages.ts

@@ -2010,13 +2010,18 @@ export function failedToOpenBrowser_0170(error: string): QuickMessage {
  * the interpretation of compatible feed services slightly and has an impact of the usage
  * of the pilet in the browser.
  *
- * The selected schema version needs to be either "v0" or "v1".
+ * The selected schema version needs to be either "v0", "v1", or "v2".
  *
  * - v0: will download and evaluate the pilet explicitly
- * - v1: will use a script tag for integration of the pilet (default)
+ * - v1: will use a script tag for integration of the pilet
+ * - v2: will use SystemJS for integration of the pilet (default)
  *
  * The v1 version has better support for older browsers, but requires a polyfill to work
  * correctly. This polyfill is part of the standard Piral polyfills.
+ * 
+ * The v2 version uses a SystemJS format for the pilet. It has the broadest browser support
+ * but requires the custom format as output. Most bundlers support SystemJS directly or
+ * indirectly, making it a quite broad choice.
  *
  * @see
  * - [GitHub currentScript-polyfill](https://github.com/amiller-gh/currentScript-polyfill)

package/src/types/common.ts

@@ -76,6 +76,14 @@ export interface RuleContext {
   peerDependencies: Record<string, string>;
 }
 
+export interface SharedDependency {
+  id: string;
+  name: string;
+  ref: string;
+  type: 'local' | 'remote';
+  entry: string;
+}
+
 export interface RuleRunner<T extends RuleContext> {
   (context: T, options: any): void | Promise<void>;
 }
@@ -92,6 +100,7 @@ export interface PiralRuleContext extends RuleContext {
 export interface PiletRuleContext extends RuleContext {
   data: PiralData;
   peerModules: Array<string>;
+  importmap: Array<SharedDependency>;
 }
 
 export interface PiralData {

package/src/types/public.ts

@@ -6,6 +6,7 @@ import {
   Bundler,
   BundleDetails,
   LogLevels,
+  SharedDependency,
   ReleaseProvider,
 } from './common';
 
@@ -108,6 +109,7 @@ export interface DebugPiletParameters extends BaseBundleParameters {
   piral: string;
   hmr: boolean;
   externals: Array<string>;
+  importmap: Array<SharedDependency>;
   targetDir: string;
   entryModule: string;
   logLevel: LogLevels;
@@ -120,6 +122,7 @@ export interface BuildPiletParameters extends BaseBundleParameters {
   contentHash: boolean;
   minify: boolean;
   externals: Array<string>;
+  importmap: Array<SharedDependency>;
   targetDir: string;
   outFile: string;
   outDir: string;
@@ -160,7 +163,7 @@ export interface BundlerDefinition {
   buildPilet: BuildPiletBundlerDefinition;
 }
 
-export type PiletSchemaVersion = 'none' | 'v0' | 'v1';
+export type PiletSchemaVersion = 'none' | 'v0' | 'v1' | 'v2';
 
 export type PiletPublishSource = 'local' | 'npm' | 'remote';