piral-cli 0.15.3 → 0.15.4-beta.5013

package/src/common/npm.ts

@@ -419,9 +419,15 @@ export async function getPackageName(root: string, name: string, type: PackageTy
 
       if (!originalPackageJson.name) {
         const p = resolve(process.cwd(), name);
-        const s = createReadStream(p);
-        const i = await inspectPackage(s);
-        return i.name;
+
+        try {
+          const s = createReadStream(p);
+          const i = await inspectPackage(s);
+          return i.name;
+        } catch (err) {
+          log('generalError_0002', `Could not open package tarball at "${p}": "${err}`);
+          return undefined;
+        }
       }
 
       return originalPackageJson.name;
@@ -460,20 +466,22 @@ export function getPackageVersion(
   }
 }
 
-function getExternalsFrom(root: string, packageName: string): Array<string> | undefined {
+async function getExternalsFrom(root: string, packageName: string): Promise<Array<string> | undefined> {
   try {
     const target = getModulePath(root, `${packageName}/package.json`);
-    return require(target).sharedDependencies;
+    const dir = dirname(target);
+    const { sharedDependencies } = await readJson(dir, 'package.json');
+    return sharedDependencies;
   } catch (err) {
     log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
     return undefined;
   }
 }
 
-function getCoreExternals(root: string, dependencies: Record<string, string>): Array<string> {
+async function getCoreExternals(root: string, dependencies: Record<string, string>): Promise<Array<string>> {
   for (const frameworkLib of frameworkLibs) {
     if (dependencies[frameworkLib]) {
-      const deps = getExternalsFrom(root, frameworkLib);
+      const deps = await getExternalsFrom(root, frameworkLib);
 
       if (deps) {
         return deps;
@@ -485,17 +493,17 @@ function getCoreExternals(root: string, dependencies: Record<string, string>): A
   return [];
 }
 
-export function makePiletExternals(
+export async function makePiletExternals(
   root: string,
   dependencies: Record<string, string>,
   fromEmulator: boolean,
   piralInfo: any,
-): Array<string> {
+): Promise<Array<string>> {
   if (fromEmulator) {
     const { sharedDependencies = legacyCoreExternals } = piralInfo;
     return sharedDependencies;
   } else {
-    return getCoreExternals(root, dependencies);
+    return await getCoreExternals(root, dependencies);
   }
 }
 
@@ -522,7 +530,7 @@ export function mergeExternals(customExternals?: Array<string>, coreExternals: A
   return coreExternals;
 }
 
-export function makeExternals(root: string, dependencies: Record<string, string>, externals: Array<string>) {
-  const coreExternals = getCoreExternals(root, dependencies);
+export async function makeExternals(root: string, dependencies: Record<string, string>, externals: Array<string>) {
+  const coreExternals = await getCoreExternals(root, dependencies);
   return mergeExternals(externals, coreExternals);
 }

package/src/common/package.ts

@@ -167,13 +167,17 @@ export function getPiralPath(root: string, name: string) {
   return dirname(path);
 }
 
-export function findPiralInstance(proposedApp: string, baseDir: string, port: number): PiralInstancePackageData {
+export async function findPiralInstance(
+  proposedApp: string,
+  baseDir: string,
+  port: number,
+): Promise<PiralInstancePackageData> {
   const path = findPackageRoot(proposedApp, baseDir);
 
   if (path) {
     log('generalDebug_0003', `Following the app package in "${path}" ...`);
-    const appPackage = require(path);
     const root = dirname(path);
+    const appPackage = await readJson(root, basename(path));
     const relPath = appPackage && appPackage.app;
     appPackage.app = relPath && resolve(root, relPath);
     appPackage.root = root;
@@ -184,7 +188,7 @@ export function findPiralInstance(proposedApp: string, baseDir: string, port: nu
   fail('appInstanceNotFound_0010', proposedApp);
 }
 
-export function findPiralInstances(
+export async function findPiralInstances(
   proposedApps: Array<string>,
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
@@ -204,8 +208,10 @@ export function findPiralInstances(
   }
 
   if (proposedApps.length > 0) {
-    return proposedApps.map((proposedApp) =>
-      findPiralInstance(proposedApp, baseDir, piletDefinition?.piralInstances?.[proposedApp]?.port ?? 0),
+    return Promise.all(
+      proposedApps.map((proposedApp) =>
+        findPiralInstance(proposedApp, baseDir, piletDefinition?.piralInstances?.[proposedApp]?.port ?? 0),
+      ),
     );
   }
 
@@ -530,7 +536,9 @@ export async function findPackageVersion(rootPath: string, packageName: string |
       log('generalDebug_0003', `Finding the version of "${packageName}" in "${rootPath}".`);
       const moduleName = getModulePath(rootPath, pckg);
       const packageJson = await findFile(moduleName, 'package.json');
-      return require(packageJson).version;
+      const root = dirname(packageJson);
+      const { version } = await readJson(root, 'package.json');
+      return version;
     } catch {}
   }
 
@@ -555,7 +563,7 @@ export async function retrieveExternals(root: string, packageInfo: any): Promise
       ...packageInfo.dependencies,
     };
     const deps = packageInfo.pilets?.externals;
-    const externals = makeExternals(root, allDeps, deps);
+    const externals = await makeExternals(root, allDeps, deps);
     return externals.map((ext) => ({
       id: ext,
       name: ext,
@@ -583,7 +591,7 @@ export async function retrievePiletsInfo(entryFile: string) {
   }
 
   const root = dirname(packageJson);
-  const packageInfo = require(packageJson);
+  const packageInfo = await readJson(root, 'package.json');
   const info = getPiletsInfo(packageInfo);
   const externals = await retrieveExternals(root, packageInfo);
   const dependencies = {
@@ -659,7 +667,7 @@ async function getPiletPackage(
         ...info.scripts,
       }
     : info.scripts;
-  const allExternals = makePiletExternals(root, piralDependencies, fromEmulator, piralInfo);
+  const allExternals = await makePiletExternals(root, piralDependencies, fromEmulator, piralInfo);
   const devDependencies: Record<string, string> = {
     ...Object.keys(typeDependencies).reduce((deps, name) => {
       deps[name] = piralDependencies[name] || typeDependencies[name];
@@ -757,9 +765,9 @@ export async function retrievePiletData(target: string, app?: string) {
   const piletJson = await findFile(target, 'pilet.json');
   const proposedRoot = piletJson ? dirname(piletJson) : target;
   const root = await findPiletRoot(proposedRoot);
-  const piletPackage = require(resolve(root, 'package.json'));
-  const piletDefinition = piletJson && require(piletJson);
-  const appPackages = findPiralInstances(app && [app], piletPackage, piletDefinition, target);
+  const piletPackage = await readJson(root, 'package.json');
+  const piletDefinition = piletJson && await readJson(proposedRoot, 'pilet.json');
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, target);
   const apps: Array<AppDefinition> = [];
 
   if (appPackages.length === 0) {

package/src/common/watcher.ts

@@ -1,24 +1,89 @@
+import { watch, existsSync } from 'fs';
+
+export interface WatcherRef<T> {
+  end: Promise<void>;
+  data: T;
+  onTrigger(cb: () => void): void;
+}
+
 export interface WatcherContext {
   onClean(dispose: () => void): void;
   watch(file: string): void;
+  dependOn<T>(ref: WatcherRef<T>): void;
+  close(): void;
+  status: 'initial' | 'reoccuring';
 }
 
-export function watcherTask(cb: (watcherContext: WatcherContext) => Promise<void>) {
-  return new Promise<void>((resolve, reject) => {
-    const disposers: Array<() => void> = [];
-    const context: WatcherContext = {
-      onClean(dispose) {
-        disposers.push(dispose);
-      },
-      watch(file) {},
-    };
-    cb(context).then(
-      () => {
-        resolve();
-      },
-      (err) => {
-        reject(err);
-      },
-    );
+export function watcherTask<T = void>(cb: (watcherContext: WatcherContext) => Promise<T>) {
+  let running = Promise.resolve();
+  let pending = false;
+  let notify = () => {};
+
+  const disposers: Array<() => void> = [];
+  const triggers: Array<() => void> = [];
+  const end = new Promise<void>(resolve => {
+    notify = resolve;
+  });
+  const ref: WatcherRef<T> = {
+    data: undefined,
+    onTrigger(cb) {
+      triggers.push(cb);
+    },
+    end,
+  };
+
+  const reRun = async () => {
+    if (!pending) {
+      pending = true;
+      await running;
+      disposers.splice(0, disposers.length).forEach((dispose) => {
+        dispose();
+      });
+      pending = false;
+      context.status = 'reoccuring';
+      await run();
+
+      triggers.splice(0, triggers.length).forEach((trigger) => {
+        trigger();
+      });
+    }
+  };
+
+  const context: WatcherContext = {
+    onClean(dispose) {
+      disposers.push(dispose);
+    },
+    watch(file) {
+      if (existsSync(file)) {
+        const watcher = watch(
+          file,
+          {
+            persistent: false,
+          },
+          reRun,
+        );
+        disposers.push(() => watcher.close());
+      }
+    },
+    dependOn(anotherRef) {
+      anotherRef.onTrigger(reRun);
+    },
+    close() {
+      cb = () => Promise.resolve(undefined);
+      reRun().then(notify);
+    },
+    status: 'initial',
+  };
+
+  const run = async () => {
+    running = cb(context).then((data) => {
+      ref.data = data;
+    });
+    await running;
+    return ref;
+  };
+
+  return new Promise<WatcherRef<T>>((resolve, reject) => {
+    run().then(resolve, reject);
   });
 }

package/src/types/public.ts

@@ -90,6 +90,7 @@ export interface BuildPiralParameters extends BaseBundleParameters {
   emulator: boolean;
   standalone: boolean;
   sourceMaps: boolean;
+  watch: boolean;
   contentHash: boolean;
   minify: boolean;
   externals: Array<string>;
@@ -116,6 +117,7 @@ export interface DebugPiletParameters extends BaseBundleParameters {
 export interface BuildPiletParameters extends BaseBundleParameters {
   piralInstances: Array<string>;
   sourceMaps: boolean;
+  watch: boolean;
   contentHash: boolean;
   minify: boolean;
   externals: Array<string>;