piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/common/io.ts

@@ -1,11 +1,12 @@
 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 { join, resolve, basename, dirname, extname } from 'path';
+import { exists, lstat, unlink, statSync } from 'fs';
+import { mkdtemp, mkdir, constants } from 'fs';
+import { writeFile, readFile, readdir, copyFile } from 'fs';
+import { packageJson, piletJson } from './constants';
 import { log } from './log';
 import { deepMerge } from './merge';
-import { nodeVersion } from './info';
 import { computeHash } from './hash';
 import { ForceOverwrite } from './enums';
 import { promptConfirm } from './interactive';
@@ -16,41 +17,29 @@ function promptOverwrite(file: string) {
   return promptConfirm(message, false);
 }
 
-function createDirectoryLegacy(targetDir: string) {
-  const initDir = isAbsolute(targetDir) ? sep : '';
-
-  return targetDir.split(sep).reduce((parentDir, childDir) => {
-    const curDir = resolve(parentDir, childDir);
-
-    try {
-      mkdirSync(curDir);
-    } catch (err) {
-      if (err.code === 'EEXIST') {
-        return curDir;
-      }
-
-      if (err.code === 'ENOENT') {
-        throw new Error(`EACCES: permission denied, mkdir '${parentDir}'`);
-      }
-
-      const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1;
-
-      if (!caughtErr || (caughtErr && curDir === resolve(targetDir))) {
-        throw err;
-      }
-    }
-
-    return curDir;
-  }, initDir);
-}
-
 function isFile(file: string) {
   return statSync(file).isFile();
 }
 
-function isLegacy() {
-  const parts = nodeVersion.split('.');
-  return +parts[0] < 10 || (+parts[0] === 10 && +parts[1] < 12);
+export interface Destination {
+  outDir: string;
+  outFile: string;
+}
+
+export function getDestination(entryFiles: string, target: string): Destination {
+  const isdir = extname(target) !== '.html';
+
+  if (isdir) {
+    return {
+      outDir: target,
+      outFile: basename(entryFiles),
+    };
+  } else {
+    return {
+      outDir: dirname(target),
+      outFile: basename(target),
+    };
+  }
 }
 
 export async function removeAny(target: string) {
@@ -69,20 +58,8 @@ export function removeDirectory(targetDir: string) {
 }
 
 export async function createDirectory(targetDir: string) {
-  if (isLegacy()) {
-    try {
-      log('generalDebug_0003', `Trying to create "${targetDir}" in legacy mode ...`);
-      createDirectoryLegacy(targetDir);
-      return true;
-    } catch (e) {
-      log('cannotCreateDirectory_0044');
-      log('generalDebug_0003', `Error while creating ${targetDir}: ${e}`);
-      return false;
-    }
-  }
-
   try {
-    log('generalDebug_0003', `Trying to create "${targetDir}" in modern mode ...`);
+    log('generalDebug_0003', `Trying to create "${targetDir}" ...`);
     await new Promise<void>((resolve, reject) => {
       mkdir(targetDir, { recursive: true }, (err) => (err ? reject(err) : resolve()));
     });
@@ -114,6 +91,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) {
@@ -153,46 +142,155 @@ export function getFileNames(target: string) {
   });
 }
 
-export async function findFile(topDir: string, fileName: string): Promise<string> {
-  const path = join(topDir, fileName);
-  const exists = await checkExists(path);
+export async function findFile(
+  topDir: string,
+  fileName: string | Array<string>,
+  stopDir = resolve(topDir, '/'),
+): Promise<string> {
+  const fileNames = Array.isArray(fileName) ? fileName : [fileName];
 
-  if (!exists) {
-    const parentDir = resolve(topDir, '..');
+  for (const fn of fileNames) {
+    const path = join(topDir, fn);
+    const exists = await checkExists(path);
 
-    if (parentDir !== topDir) {
-      return await findFile(parentDir, fileName);
+    if (exists) {
+      return path;
     }
+  }
 
-    return undefined;
+  if (topDir !== stopDir) {
+    const parentDir = resolve(topDir, '..');
+    return await findFile(parentDir, fileNames, stopDir);
   }
 
-  return path;
+  return undefined;
 }
 
-export async function matchAny(baseDir: string, patterns: Array<string>) {
+interface AnyPattern {
+  original: string;
+  patterns: Array<string>;
+}
+
+function matchPattern(baseDir: string, pattern: string) {
+  return new Promise<Array<string>>((resolve, reject) => {
+    glob(
+      pattern,
+      {
+        cwd: baseDir,
+        nodir: true,
+        absolute: true,
+      },
+      (err, files) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(files);
+        }
+      },
+    );
+  });
+}
+
+async function matchAnyPattern(baseDir: string, pattern: AnyPattern) {
+  const matches = await Promise.all(pattern.patterns.map((pattern) => matchPattern(baseDir, pattern)));
+
+  return {
+    pattern: pattern.original,
+    results: matches.reduce((agg, curr) => [...agg, ...curr], []),
+  };
+}
+
+const preferences = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs', '.esm', '.es', '.es6', '.html'];
+
+export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
   const matches: Array<string> = [];
+  const pilets: Array<string> = [];
+  const matched = (name: string, path: string) => {
+    pilets.push(name);
+    matches.push(path);
+  };
+  const exts = preferences.map((s) => s.substring(1)).join(',');
+  const allPatterns = patterns.reduce<Array<AnyPattern>>((agg, curr) => {
+    const patterns = [];
+
+    if (/[a-zA-Z0-9\-\*]$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
+      patterns.push(curr, `${curr}.{${exts}}`, `${curr}/${packageJson}`, `${curr}/${piletJson}`);
+    } else if (curr.endsWith('/')) {
+      patterns.push(`${curr}index.{${exts}}`, `${curr}${packageJson}`, `${curr}${piletJson}`);
+    } else if (curr === '.' || curr === '..') {
+      patterns.push(`${curr}/index.{${exts}}`, `${curr}/${packageJson}`, `${curr}/${piletJson}`);
+    } else {
+      patterns.push(curr);
+    }
+
+    agg.push({ original: curr, patterns });
+    return agg;
+  }, []);
+
   await Promise.all(
-    patterns.map(
-      (pattern) =>
-        new Promise<void>((resolve, reject) => {
-          glob(
-            pattern,
-            {
-              cwd: baseDir,
-            },
-            (err, files) => {
-              if (err) {
-                reject(err);
+    allPatterns.map((patterns) =>
+      matchAnyPattern(baseDir, patterns).then(async ({ results, pattern }) => {
+        if (!results.length) {
+          log('generalDebug_0003', `Found no potential entry points using "${pattern}".`);
+        } else {
+          //TODO -> shouldn't take the first one,
+          // should be the first one, yes, but, PER pilet
+          // so that multiple pilets can be considered, too
+          log('generalDebug_0003', `Found ${results.length} potential entry points in "${pattern}".`);
+
+          for (const result of results) {
+            const fileName = basename(result);
+
+            if (fileName === packageJson) {
+              log('generalDebug_0003', `Entry point is a "${packageJson}" and needs further inspection.`);
+              const targetDir = dirname(result);
+              const { source, name } = await readJson(targetDir, fileName);
+
+              if (!pilets.includes(name)) {
+                if (typeof source === 'string') {
+                  log('generalDebug_0003', `Found a "source" field with value "${source}".`);
+                  const target = resolve(targetDir, source);
+                  const exists = await checkExists(target);
+
+                  if (exists) {
+                    log('generalDebug_0003', `Taking existing target as "${target}".`);
+                    matched(name, target);
+                  } else {
+                    log('generalDebug_0003', `Source target "${target}" does not exist. Skipped.`);
+                  }
+                } else {
+                  log('generalDebug_0003', `No "source" field found. Trying combinations in "src".`);
+                  const files = await matchPattern(targetDir, `src/index.{${exts}}`);
+
+                  if (files.length > 0) {
+                    log('generalDebug_0003', `Found a result; taking "${files[0]}".`);
+                    matched(name, files[0]);
+                  } else {
+                    log('generalDebug_0003', `Found no results in "src". Skipped.`);
+                  }
+                }
+              }
+            } else {
+              const packageJsonPath = await findFile(result, packageJson);
+
+              if (packageJsonPath) {
+                const targetDir = dirname(packageJsonPath);
+                const { name } = await readJson(targetDir, packageJson);
+
+                if (!pilets.includes(name)) {
+                  log('generalDebug_0003', `Entry point result is "${result}".`);
+                  matched(name, result);
+                }
               } else {
-                matches.push(...files);
-                resolve();
+                log('generalDebug_0003', `Could not find "${packageJson}" for entry "${result}". Skipping.`);
               }
-            },
-          );
-        }),
+            }
+          }
+        }
+      }),
     ),
   );
+
   return matches;
 }
 
@@ -263,19 +361,28 @@ export async function getHash(targetFile: string) {
 
 export async function mergeWithJson<T>(targetDir: string, fileName: string, newContent: T) {
   const targetFile = join(targetDir, fileName);
-  const content = await new Promise<string>((resolve, reject) => {
-    readFile(targetFile, 'utf8', (err, c) => (err ? reject(err) : resolve(c)));
+  const content = await new Promise<string>((resolve) => {
+    readFile(targetFile, 'utf8', (err, c) => (err ? resolve('{}') : resolve(c)));
   });
   const originalContent = JSON.parse(content);
   return deepMerge(originalContent, newContent);
 }
 
-export async function readJson<T = any>(targetDir: string, fileName: string) {
+export async function readJson<T = any>(targetDir: string, fileName: string, defaultValue = {}) {
   const targetFile = join(targetDir, fileName);
   const content = await new Promise<string>((resolve) => {
     readFile(targetFile, 'utf8', (err, c) => (err ? resolve('') : resolve(c)));
   });
-  return JSON.parse(content || '{}') as T;
+
+  if (content) {
+    try {
+      return JSON.parse(content) as T;
+    } catch (ex) {
+      log('generalError_0002', `Invalid JSON found in file "${fileName}" at "${targetDir}".`);
+    }
+  }
+
+  return defaultValue as T;
 }
 
 export function readBinary(targetDir: string, fileName: string) {
@@ -319,10 +426,20 @@ export async function copy(source: string, target: string, forceOverwrite = Forc
 
   try {
     const flag = forceOverwrite === ForceOverwrite.yes ? 0 : constants.COPYFILE_EXCL;
-    await new Promise<void>((resolve, reject) => {
-      copyFile(source, target, flag, (err) => (err ? reject(err) : resolve()));
-    });
-    return true;
+    const isDir = await checkIsDirectory(source);
+
+    if (isDir) {
+      const files = await getFileNames(source);
+      const results = await Promise.all(
+        files.map((file) => copy(resolve(source, file), resolve(target, file), forceOverwrite)),
+      );
+      return results.every(Boolean);
+    } else {
+      await new Promise<void>((resolve, reject) => {
+        copyFile(source, target, flag, (err) => (err ? reject(err) : resolve()));
+      });
+      return true;
+    }
   } catch (e) {
     if (forceOverwrite === ForceOverwrite.prompt) {
       const shouldOverwrite = await promptOverwrite(target);

package/src/common/language.ts

@@ -1,24 +1,101 @@
 import { log } from './log';
-import { SourceLanguage } from './enums';
+import { Framework, SourceLanguage } from '../types';
 
-export const reactTypings = {
-  '@types/react': 'latest',
-  '@types/react-dom': 'latest',
-  '@types/react-router': 'latest',
-  '@types/react-router-dom': 'latest',
+const react17Deps = {
+  react: '^17',
+  'react-dom': '^17',
 };
 
-export function getDevDependencies(language: SourceLanguage, typings: Record<string, string> = reactTypings) {
+const react18Deps = {
+  react: '^18',
+  'react-dom': '^18',
+};
+
+const reactRouter5Deps = {
+  'react-router': '^5',
+  'react-router-dom': '^5',
+};
+
+const reactRouter6Deps = {
+  'react-router': '^6',
+  'react-router-dom': '^6',
+};
+
+const react17Typings = {
+  '@types/react': '^17',
+  '@types/react-dom': '^17',
+};
+
+const react18Typings = {
+  '@types/react': '^18',
+  '@types/react-dom': '^18',
+};
+
+const reactRouter5Typings = {
+  '@types/react-router': '^5',
+  '@types/react-router-dom': '^5',
+};
+
+const defaultDeps = {};
+
+const defaultTypings = {
+  '@types/react': '*',
+  '@types/react-dom': '*',
+};
+
+export function getDependencyPackages(framework: Framework, reactVersion: number, reactRouterVersion: number) {
+  // take default packages only if piral-core
+  return framework === 'piral-base'
+    ? {}
+    : {
+        ...(reactVersion < 18 ? react17Deps : react18Deps),
+        ...(reactRouterVersion < 6 ? reactRouter5Deps : reactRouter6Deps),
+      };
+}
+
+export function getDevDependencyPackages(framework: Framework, reactVersion: number, reactRouterVersion: number) {
+  // take default dev packages only if not piral-base
+  return framework === 'piral-base'
+    ? {}
+    : {
+        ...(reactVersion < 18 ? react17Typings : react18Typings),
+        ...(reactRouterVersion < 6 ? reactRouter5Typings : {}),
+      };
+}
+
+export function getFrameworkDependencies(framework: Framework, version: string) {
+  return {
+    ...(framework !== 'piral-base' ? { 'piral-base': `${version}` } : {}),
+    ...(framework !== 'piral-base' && framework !== 'piral-core' ? { 'piral-core': `${version}` } : {}),
+    [framework]: `${version}`,
+  };
+}
+
+export function getDependencies(language: SourceLanguage, packages: Record<string, string> = defaultDeps) {
+  switch (language) {
+    case 'js':
+    case 'ts':
+      return {
+        ...packages,
+      };
+    default:
+      log('generalDebug_0003', 'Did not find a valid language. Skipping "dependencies".');
+      return {};
+  }
+}
+
+export function getDevDependencies(language: SourceLanguage, typings: Record<string, string> = defaultTypings) {
   switch (language) {
-    case SourceLanguage.ts:
+    case 'ts':
       return {
         ...typings,
         '@types/node': 'latest',
         typescript: 'latest',
       };
-    case SourceLanguage.js:
+    case 'js':
+      return {};
     default:
-      log('generalDebug_0003', 'Did not find a valid language. Just skipping devDependencies.');
+      log('generalDebug_0003', 'Did not find a valid language. Skipping "devDependencies".');
       return {};
   }
 }

package/src/common/log.ts

@@ -1,94 +1,80 @@
 import * as messages from '../messages';
-import { join } from 'path';
 import { format } from 'util';
-import { createWriteStream } from 'fs';
-import { isWindows } from './info';
-import { stripAnsi } from '../external';
+import { ora } from '../external';
 import { LogLevels, QuickMessage } from '../types';
 
 type Messages = typeof messages;
 type MessageTypes = keyof Messages;
+let currentProgress: string = undefined;
+let logLevel = LogLevels.info;
+let instance = ora();
 
-const logger = (() => {
-  try {
-    return require('@parcel/logger');
-  } catch {
-    return require('../external').logger;
-  }
-})();
-
-// unfortunately, Parcel's support for verbose logging on Windows is broken
-if (isWindows) {
-  logger.verbose = function (message: string) {
-    if (this.logLevel < 4) {
-      return;
-    }
-
-    const currDate = new Date();
-    message = `[${currDate.toLocaleTimeString()}]: ${message}`;
-
-    if (this.logLevel > 4) {
-      if (!this.logFile) {
-        // the critical line is the filename; it must not contain colons!
-        const timestamp = currDate.toISOString().replace(/:/g, '');
-        const fileName = `parcel-debug-${timestamp}.log`;
-        this.logFile = createWriteStream(join(process.cwd(), fileName));
-      }
-
-      this.logFile.write(stripAnsi.default(message) + '\n');
-    }
-
-    this._log(message);
-  };
+export function getLogLevel(): LogLevels {
+  return logLevel;
 }
 
-export function setLogLevel(logLevel: LogLevels) {
-  logger.setOptions({ logLevel });
+export function setLogLevel(value: LogLevels) {
+  logLevel = value;
 }
 
 export function logInfo(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.log(msg);
+  instance.info(msg);
   return msg;
 }
 
 export function logDebug(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.verbose(msg);
+
+  if (logLevel >= LogLevels.debug) {
+    instance.info(msg);
+  }
+
   return msg;
 }
 
 export function logVerbose(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.logLevel > 3 && logger.log(msg);
+
+  if (logLevel >= LogLevels.verbose) {
+    instance.info(msg);
+  }
+
   return msg;
 }
 
 export function logDone(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.success(msg);
+  instance.succeed(msg);
   return msg;
 }
 
 export function logWarn(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.warn(msg);
+  instance.warn(msg);
   return msg;
 }
 
 export function logFail(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.error(msg);
+  instance.fail(msg);
   return msg;
 }
 
 export function progress(message: string, ...args: Array<string | number | boolean>) {
-  logger.progress(format(message, ...args));
+  const msg = format(message, ...args)
+  instance.start(msg);
+  currentProgress = msg;
 }
 
 export function logReset() {
-  logger.lines = 0;
-  logger.stopSpinner();
+  instance.stop();
+}
+
+export function logSuspend() {
+  logReset();
+
+  return () => instance.start(currentProgress);
 }
 
 export function fail<T extends MessageTypes>(type: T, ...args: Parameters<Messages[T]>): never {