piral-cli 1.4.0-beta.6243 → 1.4.0-beta.6247

package/src/bundler.ts

@@ -122,7 +122,7 @@ export async function callPiralDebug(args: DebugPiralParameters, bundlerName?: s
   try {
     const action = bundler.actions.debugPiral;
     const params = await prepareArgs(action, args);
-    return await callDynamic('debug-piral', action.path, params);
+    return await callDynamic('debug-piral', action.path, params, action.exec);
   } catch (err) {
     fail('bundlingFailed_0174', err);
   }
@@ -134,7 +134,7 @@ export async function callPiletDebug(args: DebugPiletParameters, bundlerName?: s
   try {
     const action = bundler.actions.debugPilet;
     const params = await prepareArgs(action, args);
-    return await callDynamic('debug-pilet', action.path, params);
+    return await callDynamic('debug-pilet', action.path, params, action.exec);
   } catch (err) {
     fail('bundlingFailed_0174', err);
   }
@@ -146,7 +146,7 @@ export async function callPiralBuild(args: BuildPiralParameters, bundlerName?: s
   try {
     const action = bundler.actions.buildPiral;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('build-piral', action.path, params);
+    const instance = await callStatic('build-piral', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);
@@ -159,7 +159,7 @@ export async function callPiletBuild(args: BuildPiletParameters, bundlerName?: s
   try {
     const action = bundler.actions.buildPilet;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('build-pilet', action.path, params);
+    const instance = await callStatic('build-pilet', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);
@@ -175,7 +175,7 @@ export async function callDebugPiralFromMonoRepo(
   try {
     const action = bundler.actions.watchPiral;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('debug-mono-piral', action.path, params);
+    const instance = await callStatic('debug-mono-piral', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);

package/src/common/emulator.ts

@@ -9,7 +9,7 @@ import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
 import { createDirectory, removeDirectory, matchFiles, removeAny, getFileNames } from './io';
 import { updateExistingJson, readJson, writeJson, createFileIfNotExists } from './io';
-import { LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
+import { EmulatorWebsiteManifest, LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
 
 export async function createEmulatorSources(
   sourceDir: string,
@@ -102,7 +102,7 @@ export async function createEmulatorSources(
     },
     main: `./${join(appDir, 'index.js')}`,
     typings: `./${join(appDir, 'index.d.ts')}`,
-    app: `./${join(appDir, '/index.html')}`,
+    app: `./${join(appDir, 'index.html')}`,
     peerDependencies: {},
     optionalDependencies,
     devDependencies: {
@@ -211,38 +211,34 @@ export async function createEmulatorWebsite(
   }, {} as Record<string, string>);
 
   const allFiles = await matchFiles(targetDir, '*');
-
-  await writeJson(
-    targetDir,
-    'emulator.json',
-    {
-      name: piralPkg.name,
-      description: piralPkg.description,
-      version: piralPkg.version,
-      timestamp: new Date().toISOString(),
-      scaffolding: {
-        pilets,
-        cli: cliVersion,
-      },
-      files: {
-        typings: 'index.d.ts',
-        main: basename(targetFile),
-        app: 'index.html',
-        assets: allFiles.map(file => relative(targetDir, file)),
-      },
-      importmap: {
-        imports: importmapEntries,
-      },
-      dependencies: {
-        optional: optionalDependencies,
-        included: {
-          ...allDeps,
-          ...externalDependencies,
-        },
+  const data: EmulatorWebsiteManifest = {
+    name: piralPkg.name,
+    description: piralPkg.description,
+    version: piralPkg.version,
+    timestamp: new Date().toISOString(),
+    scaffolding: {
+      pilets,
+      cli: cliVersion,
+    },
+    files: {
+      typings: 'index.d.ts',
+      main: basename(targetFile),
+      app: 'index.html',
+      assets: allFiles.map((file) => relative(targetDir, file)),
+    },
+    importmap: {
+      imports: importmapEntries,
+    },
+    dependencies: {
+      optional: optionalDependencies,
+      included: {
+        ...allDeps,
+        ...externalDependencies,
       },
     },
-    true,
-  );
+  };
+
+  await writeJson(targetDir, 'emulator.json', data, true);
 
   // generate the associated index.d.ts
   await createPiralDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);

package/src/common/index.ts

@@ -36,3 +36,4 @@ export * from './template';
 export * from './url';
 export * from './version';
 export * from './watcher';
+export * from './website';

package/src/common/npm.ts

@@ -195,7 +195,7 @@ export function publishNpmPackage(
   interactive = false,
 ): Promise<string> {
   const { publishPackage, loginUser } = clients.npm;
-  return publishPackage(target, file, ...flags).catch(err => {
+  return publishPackage(target, file, ...flags).catch((err) => {
     if (!interactive) {
       throw err;
     }
@@ -266,13 +266,13 @@ export function makeNpmAlias(name: string, version: string) {
 }
 
 export function isGitPackage(fullName: string) {
-  log('generalDebug_0003', 'Checking if its a Git package ...');
+  log('generalDebug_0003', 'Checking if its a git package ...');
 
   if (fullName) {
     const gitted = fullName.startsWith(gitPrefix);
 
     if (gitted || /^(https?|ssh):\/\/.*\.git$/.test(fullName)) {
-      log('generalDebug_0003', 'Found a Git package by name.');
+      log('generalDebug_0003', 'Found a git package by name.');
       return true;
     }
   }
@@ -280,6 +280,17 @@ export function isGitPackage(fullName: string) {
   return false;
 }
 
+export function isRemotePackage(fullName: string) {
+  log('generalDebug_0003', 'Checking if its a remote package ...');
+
+  if (fullName && /^https?:\/\/.*/.test(fullName)) {
+    log('generalDebug_0003', 'Found a remote package by name.');
+    return true;
+  }
+
+  return false;
+}
+
 export function makeGitUrl(fullName: string) {
   const gitted = fullName.startsWith(gitPrefix);
   return gitted ? fullName : `${gitPrefix}${fullName}`;
@@ -309,6 +320,8 @@ export async function dissectPackageName(
   if (isGitPackage(fullName)) {
     const gitUrl = makeGitUrl(fullName);
     return [gitUrl, 'latest', false, 'git'];
+  } else if (isRemotePackage(fullName)) {
+    return [fullName, 'latest', false, 'remote'];
   } else if (isLocalPackage(baseDir, fullName)) {
     const fullPath = resolveAbsPath(baseDir, fullName);
     const exists = await checkExists(fullPath);

package/src/common/package.ts

@@ -11,34 +11,15 @@ import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, tryResolvePackage, isNpmPackage } from './npm';
 import { makePiletExternals, makeExternals, findPackageRoot, findSpecificVersion, makeNpmAlias } from './npm';
-import { getModulePath } from '../external';
+import { scaffoldFromEmulatorWebsite } from './website';
 import { getDependencies, getDependencyPackages, getDevDependencies } from './language';
 import { getDevDependencyPackages, getFrameworkDependencies } from './language';
-import {
-  declarationEntryExtensions,
-  piralJsonSchemaUrl,
-  piletJsonSchemaUrl,
-  filesTar,
-  filesOnceTar,
-  bundlerNames,
-  frameworkLibs,
-  piralJson,
-  piletJson,
-  packageJson,
-} from './constants';
-import {
-  SourceLanguage,
-  Framework,
-  FileInfo,
-  PiletsInfo,
-  TemplateFileLocation,
-  PiletPackageData,
-  PiralPackageData,
-  SharedDependency,
-  PiletDefinition,
-  AppDefinition,
-  PiralInstancePackageData,
-} from '../types';
+import { piralJsonSchemaUrl, piletJsonSchemaUrl, filesTar, filesOnceTar, bundlerNames } from './constants';
+import { frameworkLibs, declarationEntryExtensions, piralJson, piletJson, packageJson } from './constants';
+import { getModulePath } from '../external';
+import { PiletsInfo, SharedDependency, PiletDefinition, AppDefinition } from '../types';
+import { SourceLanguage, PiralInstancePackageData, PiralInstanceDetails } from '../types';
+import { Framework, FileInfo, TemplateFileLocation, PiletPackageData, PiralPackageData } from '../types';
 
 export interface PiralInstanceData {
   packageName: Framework;
@@ -168,10 +149,10 @@ export function getPiralPath(root: string, name: string) {
 
 export async function findPiralInstance(
   proposedApp: string,
-  baseDir: string,
-  port: number,
+  rootDir: string,
+  details?: PiralInstanceDetails,
 ): Promise<PiralInstancePackageData> {
-  const path = findPackageRoot(proposedApp, baseDir);
+  const path = findPackageRoot(proposedApp, rootDir);
 
   if (path) {
     log('generalDebug_0003', `Following the app package in "${path}" ...`);
@@ -180,8 +161,13 @@ export async function findPiralInstance(
     const relPath = appPackage && appPackage.app;
     appPackage.app = relPath && resolve(root, relPath);
     appPackage.root = root;
-    appPackage.port = port;
+    appPackage.port = details?.port || 0;
     return appPackage;
+  } else if (details?.url) {
+    const { url, ...rest } = details;
+    log('generalDebug_0003', `Piral instance not installed yet - trying from remote "${url}" ...`);
+    await scaffoldFromEmulatorWebsite(rootDir, url);
+    return await findPiralInstance(proposedApp, rootDir, rest);
   }
 
   fail('appInstanceNotFound_0010', proposedApp);
@@ -191,7 +177,7 @@ export async function findPiralInstances(
   proposedApps: Array<string>,
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
-  baseDir: string,
+  rootDir: string,
 ) {
   if (proposedApps) {
     // do nothing
@@ -209,7 +195,7 @@ export async function findPiralInstances(
   if (proposedApps.length > 0) {
     return Promise.all(
       proposedApps.map((proposedApp) =>
-        findPiralInstance(proposedApp, baseDir, piletDefinition?.piralInstances?.[proposedApp]?.port ?? 0),
+        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp]),
       ),
     );
   }
@@ -220,7 +206,7 @@ export async function findPiralInstances(
 export function readPiralPackage(root: string, name: string): Promise<PiralPackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
-  return readJson(path, 'package.json');
+  return readJson(path, packageJson);
 }
 
 export async function patchPiralPackage(
@@ -653,7 +639,7 @@ export async function patchPiletPackage(
   version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
-  newInfo?: { language: SourceLanguage; bundler: string },
+  newInfo?: { language: SourceLanguage; bundler: string; details: PiralInstanceDetails },
 ) {
   log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
   const pkg = await getPiletPackage(root, name, version, piralInfo, fromEmulator, newInfo);
@@ -664,7 +650,7 @@ export async function patchPiletPackage(
   await updateExistingJson(root, piletJson, {
     $schema: piletJsonSchemaUrl,
     piralInstances: {
-      [name]: {},
+      [name]: newInfo?.details || {},
     },
   });
   log('generalDebug_0003', `Succesfully patched the pilet.json.`);
@@ -797,7 +783,7 @@ export async function retrievePiletData(target: string, app?: string) {
   const root = await findPiletRoot(proposedRoot);
   const piletPackage = await readJson(root, 'package.json');
   const piletDefinition: PiletDefinition = piletJsonPath && (await readJson(proposedRoot, piletJson));
-  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, target);
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root);
   const apps: Array<AppDefinition> = [];
 
   for (const appPackage of appPackages) {

package/src/common/shell.ts

@@ -1,24 +1,26 @@
 import { progress } from './log';
-import {
-  combinePackageRef,
-  dissectPackageName,
-  getPackageName,
-  getPackageVersion,
-  installNpmPackage,
-  isLinkedPackage,
-} from './npm';
-import { NpmClientType } from '../types';
+import { scaffoldFromEmulatorWebsite } from './website';
+import { combinePackageRef, getPackageName, getPackageVersion } from './npm';
+import { dissectPackageName, installNpmPackage, isLinkedPackage } from './npm';
+import { NpmClientType, PiralInstanceDetails } from '../types';
 
 export async function installPiralInstance(
   usedSource: string,
   baseDir: string,
   rootDir: string,
   npmClient: NpmClientType,
-): Promise<[name: string, version: string]> {
+): Promise<[name: string, version: string, details: PiralInstanceDetails]> {
   const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
-  const isLocal = isLinkedPackage(sourceName, type, hadVersion, rootDir);
 
-  if (!isLocal) {
+  if (type === 'remote') {
+    progress(`Downloading emulator from %s ...`, sourceName);
+    const emulatorJson = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
+    const details = {
+      url: sourceName,
+    };
+
+    return [emulatorJson.name, emulatorJson.version, details];
+  } else if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
     const packageRef = combinePackageRef(sourceName, sourceVersion, type);
 
     progress(`Installing npm package %s ...`, packageRef);
@@ -29,6 +31,5 @@ export async function installPiralInstance(
 
   const packageName = await getPackageName(rootDir, sourceName, type);
   const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
-
-  return [packageName, packageVersion];
+  return [packageName, packageVersion, {}];
 }

package/src/common/website.ts

@@ -0,0 +1,67 @@
+import { resolve as resolveUrl } from 'url';
+import { join, resolve } from 'path';
+import { createPiralStubIndexIfNotExists } from './template';
+import { packageJson } from './constants';
+import { ForceOverwrite } from './enums';
+import { createDirectory, writeBinary } from './io';
+import { writeJson } from './io';
+import { axios } from '../external';
+import { EmulatorWebsiteManifestFiles, EmulatorWebsiteManifest } from '../types';
+
+async function downloadEmulatorFiles(manifestUrl: string, target: string, files: EmulatorWebsiteManifestFiles) {
+  const requiredFiles = [files.typings, files.main, files.app];
+
+  await Promise.all(
+    requiredFiles.map(async (file) => {
+      const res = await axios.default.get(resolveUrl(manifestUrl, file), { responseType: 'arraybuffer' });
+      const data: Buffer = res.data;
+      await writeBinary(target, file, data);
+    }),
+  );
+}
+
+export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string) {
+  const response = await axios.default.get(manifestUrl);
+  const emulatorJson: EmulatorWebsiteManifest = response.data;
+
+  const targetDir = resolve(rootDir, 'node_modules', emulatorJson.name);
+  const appDirName = 'app';
+  const mainFile = 'index.js';
+  const appDir = resolve(targetDir, appDirName);
+  await createDirectory(appDir);
+
+  await writeJson(
+    targetDir,
+    packageJson,
+    {
+      name: emulatorJson.name,
+      description: emulatorJson.description,
+      version: emulatorJson.version,
+      importmap: emulatorJson.importmap,
+      pilets: emulatorJson.scaffolding.pilets,
+      piralCLI: {
+        version: emulatorJson.scaffolding.cli,
+        timestamp: emulatorJson.timestamp,
+        source: manifestUrl,
+        generated: true,
+      },
+      files: emulatorJson.files,
+      main: `./${join(appDirName, mainFile)}`,
+      typings: `./${join(appDirName, emulatorJson.files.typings)}`,
+      app: `./${join(appDirName, emulatorJson.files.app)}`,
+      peerDependencies: {},
+      optionalDependencies: emulatorJson.dependencies.optional,
+      devDependencies: emulatorJson.dependencies.included,
+    },
+    true,
+  );
+
+  // actually including this one hints that the app shell should have been included - which is forbidden
+  await createPiralStubIndexIfNotExists(appDir, mainFile, ForceOverwrite.yes, {
+    name: emulatorJson.name,
+    outFile: emulatorJson.files.main,
+  });
+
+  await downloadEmulatorFiles(manifestUrl, appDir, emulatorJson.files);
+  return emulatorJson;
+}

package/src/types/common.ts

@@ -4,6 +4,30 @@ export interface Importmap {
   exclude?: Array<string>;
 }
 
+export interface EmulatorWebsiteManifestFiles {
+  typings: string;
+  main: string;
+  app: string;
+  assets: Array<string>;
+}
+
+export interface EmulatorWebsiteManifest {
+  name: string;
+  description: string;
+  version: string;
+  timestamp: string;
+  scaffolding: {
+    pilets: PiletsInfo;
+    cli: string;
+  };
+  files: EmulatorWebsiteManifestFiles;
+  importmap: Importmap;
+  dependencies: {
+    optional: Record<string, string>;
+    included: Record<string, string>;
+  };
+}
+
 export interface PackageData {
   name: string;
   version: string;

package/src/types/internal.ts

@@ -1,19 +1,20 @@
 import type { LogLevels } from './common';
 import type { ImportmapVersions, PiletSchemaVersion } from './public';
 
+export interface PiralInstanceDetails {
+  selected?: boolean;
+  port?: number;
+  path?: string;
+  url?: string;
+}
+
 /**
  * Shape of the pilet.json
  */
 export interface PiletDefinition {
   schemaVersion?: PiletSchemaVersion;
   importmapVersions?: ImportmapVersions;
-  piralInstances?: Record<
-    string,
-    {
-      selected?: boolean;
-      port?: number;
-    }
-  >;
+  piralInstances?: Record<string, PiralInstanceDetails>;
 }
 
 export interface PackageFiles {

package/src/types/public.ts

@@ -136,6 +136,7 @@ export interface BundlerPrepareArgs<T> {
 
 export interface BaseBundlerDefinition<T> {
   path: string;
+  exec?: string;
   prepare?: BundlerPrepareArgs<T>;
 }
 
@@ -235,7 +236,7 @@ export type PiralBuildType = 'all' | 'release' | 'emulator' | 'emulator-sources'
 
 export type PiletBuildType = 'default' | 'standalone' | 'manifest';
 
-export type PackageType = 'registry' | 'file' | 'git';
+export type PackageType = 'registry' | 'file' | 'git' | 'remote';
 
 export type NpmClientType = 'npm' | 'yarn' | 'pnp' | 'pnpm' | 'lerna' | 'rush' | 'bun';