piral-cli 0.15.0-alpha.4396 → 0.15.0-beta.4411

package/src/common/io.ts

@@ -1,8 +1,9 @@
 import * as rimraf from 'rimraf';
 import { transpileModule, ModuleKind, ModuleResolutionKind, ScriptTarget, JsxEmit } from 'typescript';
 import { join, resolve, basename, dirname, extname, isAbsolute, sep } from 'path';
-import { exists, mkdir, lstat, unlink, mkdirSync, statSync } from 'fs';
-import { writeFile, readFile, readdir, copyFile, constants } from 'fs';
+import { exists, lstat, unlink, statSync } from 'fs';
+import { mkdtemp, mkdir, mkdirSync, constants } from 'fs';
+import { writeFile, readFile, readdir, copyFile } from 'fs';
 import { log } from './log';
 import { deepMerge } from './merge';
 import { nodeVersion } from './info';
@@ -135,6 +136,18 @@ export async function getEntryFiles(content: string, basePath: string) {
   return results;
 }
 
+export function makeTempDir(prefix: string) {
+  return new Promise<string>((resolve, reject) =>
+    mkdtemp(prefix, (err, folder) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(folder);
+      }
+    }),
+  );
+}
+
 export function checkExists(target: string) {
   return new Promise<boolean>((resolve) => {
     if (target !== undefined) {
@@ -174,15 +187,14 @@ export function getFileNames(target: string) {
   });
 }
 
-export async function findFile(topDir: string, fileName: string): Promise<string> {
+export async function findFile(topDir: string, fileName: string, stopDir = resolve(topDir, '/')): Promise<string> {
   const path = join(topDir, fileName);
   const exists = await checkExists(path);
 
   if (!exists) {
-    const parentDir = resolve(topDir, '..');
-
-    if (parentDir !== topDir) {
-      return await findFile(parentDir, fileName);
+    if (topDir !== stopDir) {
+      const parentDir = resolve(topDir, '..');
+      return await findFile(parentDir, fileName, stopDir);
     }
 
     return undefined;

package/src/common/pack.test.ts

@@ -1,21 +1,18 @@
 import { createPiletPackage } from './pack';
 import { resolve } from 'path';
 
-let json = {};
+let json: any = {};
 
 jest.mock('./io', () => ({
-  readJson: (dir: string, source: string) => {
-    return json;
-  },
-  move: (source: string, target: string, forceOverwrite?: any) => {
-    return Promise.resolve('foo');
-  },
+  readJson: jest.fn(() => json),
+  removeDirectory: jest.fn(() => Promise.resolve()),
+  makeTempDir: jest.fn(() => Promise.resolve('')),
+  copy: jest.fn(() => Promise.resolve()),
+  checkExists: jest.fn(() => Promise.resolve(true)),
 }));
 
-jest.mock('./npm', () => ({
-  createNpmPackage: (target?: string) => {
-    return Promise.resolve(target);
-  },
+jest.mock('./archive', () => ({
+  createTgz: jest.fn(() => Promise.resolve()),
 }));
 
 describe('Pack Module', () => {
@@ -51,7 +48,7 @@ describe('Pack Module', () => {
 
   it('createPilePackage source <> target', async () => {
     json = { name: 'foo', version: '1.0.0' };
-    const path = resolve('./', 'foo-1.0.0.tgz');
-    await expect(createPiletPackage('./', '', 'test')).resolves.toEqual('foo');
+    const path = resolve('./', 'test', 'foo-1.0.0.tgz');
+    await expect(createPiletPackage('./', '', 'test')).resolves.toEqual(path);
   });
 });

package/src/common/pack.ts

@@ -1,20 +1,22 @@
-import { resolve, join } from 'path';
+import { tmpdir } from 'os';
+import { resolve, relative, join, dirname, basename } from 'path';
+import { createTgz } from './archive';
 import { log, progress, fail } from './log';
-import { readJson, move } from './io';
-import { createNpmPackage } from './npm';
-import { ForceOverwrite } from './enums';
-
-async function getFile(root: string, name: string, dest: string) {
-  const proposed = join(root, name);
-
-  if (dest !== root) {
-    log('generalDebug_0003', `Moving file from "${root}" to "${dest}" ...`);
-    const file = await move(proposed, dest, ForceOverwrite.yes);
-    log('generalDebug_0003', 'Successfully moved file.');
-    return file;
+import { readJson, copy, removeDirectory, checkExists, makeTempDir } from './io';
+import { getPossiblePiletMainPaths } from './inspect';
+
+async function getPiletContentDir(root: string, packageData: any) {
+  const paths = getPossiblePiletMainPaths(packageData);
+
+  for (const path of paths) {
+    const file = resolve(root, path);
+
+    if (await checkExists(file)) {
+      return dirname(file);
+    }
   }
 
-  return proposed;
+  return root;
 }
 
 export async function createPiletPackage(baseDir: string, source: string, target: string) {
@@ -36,13 +38,33 @@ export async function createPiletPackage(baseDir: string, source: string, target
     fail('packageJsonMissingVersion_0022');
   }
 
-  progress(`Packing pilet in ${dest} ...`);
-  log('generalDebug_0003', 'Creating package ...');
-  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}".`);
-  const file = await getFile(root, name, dest);
+  const isFileTarget = target.endsWith('.tgz');
+  progress(`Packing pilet in "${root}" ...`);
+
+  const pckgName = pckg.name.replace(/@/g, '').replace(/\//g, '-');
+  const id = `${pckgName}-${pckg.version}`;
+  const name = isFileTarget ? basename(target) : `${id}.tgz`;
+  const file = isFileTarget ? dest : resolve(dest, name);
+  log('generalDebug_0003', `Assume package name "${name}".`);
+
+  const content = await getPiletContentDir(root, pckg);
+  const files = [resolve(root, 'package.json'), content];
+  const prefix = join(tmpdir(), `${id}-`);
+  const cwd = await makeTempDir(prefix);
+  log('generalDebug_0003', `Creating package with content from "${content}" ...`);
+
+  await Promise.all(files.map((file) => copy(file, resolve(cwd, relative(root, file)))));
+
+  await createTgz(
+    file,
+    cwd,
+    files.map((f) => relative(root, f)),
+  );
+
+  log('generalDebug_0003', `Successfully created package from "${cwd}".`);
+
+  await removeDirectory(cwd);
+
   log('generalDebug_0003', `Packed file "${file}".`);
   return file;
 }

package/src/common/package.ts

@@ -12,7 +12,15 @@ 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 { SourceLanguage, Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
+import {
+  SourceLanguage,
+  Framework,
+  FileInfo,
+  PiletsInfo,
+  TemplateFileLocation,
+  PackageData,
+  SharedDependency,
+} from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -182,7 +190,6 @@ export function getPiralPackage(app: string, data: PiralPackageData, version: st
         framework === 'piral-native' && 'piral-native', // this we also only take if we selected piral-native
       ].filter(Boolean),
     },
-    pilets: getPiletsInfo({}),
     dependencies,
     devDependencies,
   };
@@ -501,10 +508,6 @@ export async function patchPiletPackage(
 ) {
   log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
   const { externals, packageOverrides, ...info } = getPiletsInfo(piralInfo);
-  const piral = {
-    comment: 'Keep this section to use the Piral CLI.',
-    name,
-  };
   const piralDependencies = {
     ...piralInfo.devDependencies,
     ...piralInfo.dependencies,
@@ -518,21 +521,7 @@ export async function patchPiletPackage(
         ...info.scripts,
       }
     : info.scripts;
-  const peerModules = [];
   const allExternals = makePiletExternals(root, piralDependencies, externals, fromEmulator, piralInfo);
-  const peerDependencies = {
-    ...allExternals.reduce((deps, name) => {
-      const valid = isValidDependency(name);
-      deps[name] = valid ? '*' : undefined;
-
-      if (!valid) {
-        peerModules.push(name);
-      }
-
-      return deps;
-    }, {}),
-    [name]: `*`,
-  };
   const devDependencies: Record<string, string> = {
     ...Object.keys(typeDependencies).reduce((deps, name) => {
       deps[name] = piralDependencies[name] || typeDependencies[name];
@@ -562,19 +551,26 @@ export async function patchPiletPackage(
     appendBundler(devDependencies, bundler, version);
   }
 
-  const packageContent = deepMerge(packageOverrides, {
-    piral,
+  await updateExistingJson(root, 'package.json', deepMerge(packageOverrides, {
+    importmap: {
+      imports: {},
+      inherit: [name],
+    },
     devDependencies,
-    peerDependencies,
-    peerModules,
     dependencies: {
       [name]: undefined,
     },
     scripts,
-  });
+  }));
 
-  await updateExistingJson(root, 'package.json', packageContent);
   log('generalDebug_0003', `Succesfully patched the package.json.`);
+
+  await updateExistingJson(root, 'pilet.json', {
+    piralInstances: {
+      [name]: {},
+    },
+  });
+  log('generalDebug_0003', `Succesfully patched the pilet.json.`);
 }
 
 /**
@@ -592,6 +588,34 @@ export function checkAppShellPackage(appPackage: PackageData) {
   return false;
 }
 
+export function combinePiletExternals(
+  appShells: Array<string>,
+  peerDependencies: Record<string, string>,
+  peerModules: Array<string>,
+  importmap: Array<SharedDependency>,
+) {
+  const externals = [...Object.keys(peerDependencies), ...peerModules];
+
+  for (let i = importmap.length; i--; ) {
+    const entry = importmap[i];
+
+    // if the entry has no parents, i.e., it was explicitly mentioned in the importmap
+    // then keep it in the importmap (=> prefer the distributed approach, which will always work)
+    if (Array.isArray(entry.parents)) {
+      // only accept entry as a centrally shared dependency if the entry appears in all
+      // mentioned / referenced app shells
+      // in other cases (e.g., if one app shell does not share this) use the distributed
+      // mechanism to ensure that the dependency can also be resolved in this shell
+      if (appShells.every((app) => entry.parents.includes(app))) {
+        externals.push(entry.name);
+        importmap.splice(i, 1);
+      }
+    }
+  }
+
+  return externals;
+}
+
 export async function retrievePiletData(target: string, app?: string) {
   const packageJson = await findFile(target, 'package.json');
 

package/src/types/common.ts

@@ -84,6 +84,7 @@ export interface SharedDependency {
   ref: string;
   type: 'local' | 'remote';
   entry: string;
+  parents?: Array<string>;
 }
 
 export interface RuleRunner<T extends RuleContext> {