piral-cli 1.3.3-beta.6190 → 1.3.3-beta.6204

package/src/common/declaration.ts

@@ -1,13 +1,15 @@
-import { DeclOptions, generateDeclaration, createExcludePlugin, Logger } from 'dets';
+import { DeclOptions, generateDeclaration, createDiffPlugin, Logger } from 'dets';
 import { dirname, basename, resolve, extname } from 'path';
 import { progress, log, logWarn, logVerbose, logInfo } from './log';
 import { ForceOverwrite } from './enums';
 import { retrievePiralRoot, retrievePiletsInfo, flattenExternals, validateSharedDependencies } from './package';
-import { entryModuleExtensions, piralBaseRoot } from './constants';
-import { readText, getEntryFiles, matchFiles, createFileIfNotExists } from './io';
+import { entryModuleExtensions, piralBaseRoot, packageJson } from './constants';
+import { readText, getEntryFiles, matchFiles, createFileIfNotExists, readJson } from './io';
 import { getModulePath } from '../external';
 import { LogLevels } from '../types';
 
+const piletApiName = 'PiletApi';
+
 function findPiralBaseRoot(root: string, framework: string) {
   const piralJson = `${framework}/package.json`;
 
@@ -21,6 +23,26 @@ function findPiralBaseRoot(root: string, framework: string) {
   return root;
 }
 
+async function findPiralInstanceApi(piralInstance: string) {
+  if (piralInstance) {
+    const path = require.resolve(`${piralInstance}/${packageJson}`);
+    const root = dirname(path);
+    const data = await readJson(root, packageJson);
+    const subpath = data.types || data.typings;
+
+    if (subpath) {
+      return [
+        {
+          file: resolve(root, subpath),
+          name: piletApiName,
+        },
+      ];
+    }
+  }
+
+  return [];
+}
+
 function findPiralBaseApi(root: string, framework: string) {
   // for some package managers, e.g., pnpm we need to first go into
   // some specifics before being able to retrieve "piral-base"
@@ -36,7 +58,7 @@ function findPiralBaseApi(root: string, framework: string) {
     return [
       {
         file: resolve(projectDir, piletApiTypings),
-        name: 'PiletApi',
+        name: piletApiName,
       },
     ];
   } catch (err) {
@@ -113,7 +135,7 @@ async function createDeclarationFile(
   progress('Bundling declaration file ...');
 
   try {
-    const result = generateDeclaration(options);
+    const result = await generateDeclaration(options);
 
     progress('Writing declaration file ...');
     await createFileIfNotExists(target, 'index.d.ts', result, forceOverwrite);
@@ -124,6 +146,7 @@ async function createDeclarationFile(
 
 export async function createPiletDeclaration(
   name: string,
+  piralInstances: Array<string>,
   root: string,
   entry: string,
   allowedImports: Array<string>,
@@ -131,21 +154,27 @@ export async function createPiletDeclaration(
   forceOverwrite: ForceOverwrite,
   logLevel: LogLevels,
 ) {
-  const files = await getAllFiles([entry]);
-  const types = findDeclaredTypings(root);
-  const options: DeclOptions = {
-    name,
-    root,
-    files,
-    types: [...types, ...files],
-    plugins: [createExcludePlugin([name])],
-    apis: [],
-    noModuleDeclaration: true,
-    imports: allowedImports,
-    logLevel,
-    logger: createLogger(),
-  };
-  return await createDeclarationFile(options, root, target, forceOverwrite);
+  const piralInstance = piralInstances[0];
+  const apis = await findPiralInstanceApi(piralInstance);
+  const file = apis.map((m) => m.file)[0];
+
+  if (file) {
+    const files = await getAllFiles([entry]);
+    const types = findDeclaredTypings(root);
+    const options: DeclOptions = {
+      name: piralInstance,
+      root,
+      files,
+      types,
+      plugins: [createDiffPlugin(file)],
+      apis,
+      noModuleDeclaration: true,
+      imports: allowedImports,
+      logLevel,
+      logger: createLogger(),
+    };
+    return await createDeclarationFile(options, root, target, forceOverwrite);
+  }
 }
 
 export async function createPiralDeclaration(

package/src/common/envs.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, vitest, beforeEach, afterEach } from 'vitest';
 import { resolve } from 'path';
 import { setStandardEnvs } from './envs';
 
@@ -7,7 +8,7 @@ describe('Environment Module', () => {
   const oldEnv = process.env;
 
   beforeEach(() => {
-    jest.resetModules();
+    vitest.resetModules();
     process.env = {};
   });
 

package/src/common/hash.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { computeHash, computeMd5 } from './hash';
 
 describe('Hash Module', () => {

package/src/common/http.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { postFile, downloadFile } from './http';
 
 const apiUrl = 'http://sample.fooo.com/api/v1/pilet';
@@ -7,79 +8,81 @@ let errorOther = false;
 let errorResponse = false;
 let errorResponse2 = false;
 
-jest.mock('../external', () => ({
-  rc(_, cfg) {
-    return cfg;
-  },
-  ora() {
-    return {
-      warn() {},
-      fail() {},
-    };
-  },
-  axios: {
-    default: {
-      post(url, _, options) {
-        const found = url === apiUrl;
-        const auth = options.headers.authorization === 'Basic 123';
+vitest.mock('../external', async () => {
+  return {
+    rc(_, cfg) {
+      return cfg;
+    },
+    ora() {
+      return {
+        warn() {},
+        fail() {},
+      };
+    },
+    axios: {
+      default: {
+        post(url, _, options) {
+          const found = url === apiUrl;
+          const auth = options.headers.authorization === 'Basic 123';
 
-        if (errorRequest) {
-          return Promise.reject({
-            request: {},
-          });
-        } else if (errorOther) {
-          return Promise.reject({
-            message: 'error',
-          });
-        } else if (errorResponse) {
-          return Promise.reject({
-            response: {
-              status: 410,
-              statusText: 'Not Gone',
-              data: '{ "message": "This component is not available anymore." }',
-            },
-          });
-        } else if (errorResponse2) {
-          return Promise.reject({
-            response: {
-              status: 410,
-              statusText: 'Not Gone',
-              data: { message: 'This component is not available anymore.' },
-            },
-          });
-        } else if (!found) {
-          return Promise.reject({
-            response: {
-              status: 404,
-              statusText: 'Not found',
-            },
-          });
-        } else if (!auth) {
-          return Promise.reject({
-            response: {
-              status: 401,
-              statusText: 'Not authorized',
-            },
-          });
-        } else {
-          return Promise.resolve({
-            status: 200,
-            statusText: 'OK',
-          });
-        }
-      },
-      get(url, options) {
-        if (errorOther) {
-          return Promise.reject({
-            message: 'error',
-          });
-        }
-        return Promise.resolve({ data: 'test' });
+          if (errorRequest) {
+            return Promise.reject({
+              request: {},
+            });
+          } else if (errorOther) {
+            return Promise.reject({
+              message: 'error',
+            });
+          } else if (errorResponse) {
+            return Promise.reject({
+              response: {
+                status: 410,
+                statusText: 'Not Gone',
+                data: '{ "message": "This component is not available anymore." }',
+              },
+            });
+          } else if (errorResponse2) {
+            return Promise.reject({
+              response: {
+                status: 410,
+                statusText: 'Not Gone',
+                data: { message: 'This component is not available anymore.' },
+              },
+            });
+          } else if (!found) {
+            return Promise.reject({
+              response: {
+                status: 404,
+                statusText: 'Not found',
+              },
+            });
+          } else if (!auth) {
+            return Promise.reject({
+              response: {
+                status: 401,
+                statusText: 'Not authorized',
+              },
+            });
+          } else {
+            return Promise.resolve({
+              status: 200,
+              statusText: 'OK',
+            });
+          }
+        },
+        get(url, options) {
+          if (errorOther) {
+            return Promise.reject({
+              message: 'error',
+            });
+          }
+          return Promise.resolve({ data: 'test' });
+        },
       },
     },
-  },
-  FormData: jest.requireActual('form-data'),
-}));
+    FormData: (await vitest.importActual('form-data') as any).default,
+  };
+});
 
 describe('HTTP Module', () => {
   it('postFile form posts a file successfully should be ok', async () => {

package/src/common/importmap.test.ts

@@ -1,6 +1,7 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { readImportmap } from './importmap';
 
-jest.mock('./npm', () => ({
+vitest.mock('./npm', () => ({
   tryResolvePackage(id, dir) {
     if (id === 'qxz') {
       return undefined;
@@ -45,7 +46,7 @@ const mockPackages = {
   },
 };
 
-jest.mock('./io', () => ({
+vitest.mock('./io', () => ({
   checkIsDirectory() {},
   getHash() {},
   readJson(dir) {

package/src/common/info.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { findCompatVersion } from './info';
 
 describe('CLI info module', () => {

package/src/common/interactive.test.ts

@@ -1,8 +1,9 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { promptConfirm, promptSelect } from './interactive';
 
 const answer = 'Yes, really';
 
-jest.mock('../external', () => ({
+vitest.mock('../external', () => ({
   rc(_, cfg) {
     return cfg;
   },

package/src/common/io.ts

@@ -1,4 +1,4 @@
-import * as rimraf from 'rimraf';
+import rimraf from 'rimraf';
 import { transpileModule, ModuleKind, ModuleResolutionKind, ScriptTarget, JsxEmit } from 'typescript';
 import { join, resolve, basename, dirname, extname } from 'path';
 import { exists, lstat, unlink, statSync } from 'fs';

package/src/common/merge.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { deepMerge } from './merge';
 
 describe('Merge Module', () => {

package/src/common/npm.test.ts

@@ -1,5 +1,6 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { resolve } from 'path';
-import { clients } from './clients';
+import { clients } from '../npm-clients';
 import {
   dissectPackageName,
   installNpmPackage,
@@ -24,10 +25,10 @@ import {
   findPackageRoot,
 } from './npm';
 
-jest.mock('child_process');
+vitest.mock('child_process');
 
-jest.mock('../external', () => ({
-  ...jest.requireActual('../external'),
+vitest.mock('../external', async () => ({
+  ...((await vitest.importActual('../external')) as any),
   rc() {},
   ora() {
     return {
@@ -58,7 +59,7 @@ let wrongCase = false;
 const jsonValueString = JSON.stringify([{ name: 'npm' }]);
 const jsonValueStringWrong = JSON.stringify([]);
 
-jest.mock('./scripts', () => ({
+vitest.mock('./scripts', () => ({
   runCommand: (exe: string, args: Array<string>, cwd: string, output?: NodeJS.WritableStream) => {
     return new Promise<void>((resolve) => {
       output?.write(wrongCase ? jsonValueStringWrong : jsonValueString, () => {});
@@ -67,29 +68,34 @@ jest.mock('./scripts', () => ({
   },
 }));
 
-jest.mock('fs', () => ({
-  ...jest.requireActual('fs'),
-  exists: (file: string, cb: (status: boolean) => void) =>
-    cb(
-      shouldFind &&
-        !file.endsWith('package.json') &&
-        !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
-    ),
-  existsSync: (file: string) => {
-    return true;
-  },
-  readFile: (file: string, type: string, callback: (err: NodeJS.ErrnoException | undefined, data: string) => void) => {
-    const fs = jest.requireActual('fs');
-
-    if (fs.existsSync(file)) {
-      return fs.readFile(file, type, callback);
-    }
-
-    return callback(undefined, '');
-  },
-  realpathSync: () => ({}),
-  readFileSync: () => '',
-}));
+vitest.mock('fs', async () => {
+  const fs = (await vitest.importActual('fs')) as any;
+  return {
+    ...fs,
+    exists: (file: string, cb: (status: boolean) => void) =>
+      cb(
+        shouldFind &&
+          !file.endsWith('package.json') &&
+          !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
+      ),
+    existsSync: (file: string) => {
+      return true;
+    },
+    readFile: (
+      file: string,
+      type: string,
+      callback: (err: NodeJS.ErrnoException | undefined, data: string) => void,
+    ) => {
+      if (fs.existsSync(file)) {
+        return fs.readFile(file, type, callback);
+      }
+
+      return callback(undefined, '');
+    },
+    realpathSync: () => ({}),
+    readFileSync: () => '',
+  };
+});
 
 describe('npm Module', () => {
   it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
@@ -488,15 +494,7 @@ describe('npm Module', () => {
 
   it('makeExternals with externals concats coreExternals', async () => {
     const externals = await makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
-    expect(externals).toEqual([
-      'foo',
-      'bar',
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-    ]);
+    expect(externals).toEqual(['foo', 'bar', 'react', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', async () => {

package/src/common/npm.ts

@@ -1,11 +1,11 @@
 import { resolve, relative, dirname } from 'path';
 import { createReadStream, existsSync } from 'fs';
 import { log, fail } from './log';
-import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
 import { legacyCoreExternals, frameworkLibs, defaultRegistry, packageJson } from './constants';
 import { inspectPackage } from './inspect';
 import { readJson, checkExists } from './io';
+import { clients, detectClients, isWrapperClient } from '../npm-clients';
 import { clientTypeKeys } from '../helpers';
 import { getModulePath } from '../external';
 import { PackageType, NpmClientType } from '../types';

package/src/common/pack.test.ts

@@ -1,20 +1,21 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { createPiletPackage } from './pack';
 import { resolve } from 'path';
 
 let json: any = {};
 
-jest.mock('./io', () => ({
-  readJson: jest.fn(() => json),
-  removeDirectory: jest.fn(() => Promise.resolve()),
-  checkIsDirectory: jest.fn(() => false),
-  makeTempDir: jest.fn(() => Promise.resolve('')),
-  copy: jest.fn(() => Promise.resolve()),
-  checkExists: jest.fn(() => Promise.resolve(true)),
-  createDirectory: jest.fn(() => Promise.resolve()),
+vitest.mock('./io', () => ({
+  readJson: vitest.fn(() => json),
+  removeDirectory: vitest.fn(() => Promise.resolve()),
+  checkIsDirectory: vitest.fn(() => false),
+  makeTempDir: vitest.fn(() => Promise.resolve('')),
+  copy: vitest.fn(() => Promise.resolve()),
+  checkExists: vitest.fn(() => Promise.resolve(true)),
+  createDirectory: vitest.fn(() => Promise.resolve()),
 }));
 
-jest.mock('./archive', () => ({
-  createTgz: jest.fn(() => Promise.resolve()),
+vitest.mock('./archive', () => ({
+  createTgz: vitest.fn(() => Promise.resolve()),
 }));
 
 describe('Pack Module', () => {