@teambit/isolator 0.0.566 → 0.0.570

package/capsule/capsule.ts

@@ -0,0 +1,138 @@
+import { NodeFS } from '@teambit/any-fs';
+import { Capsule as CapsuleTemplate, Console, Exec, State } from '@teambit/capsule';
+import { Component } from '@teambit/component';
+import filenamify from 'filenamify';
+import { realpathSync } from 'fs';
+import glob from 'glob';
+import path from 'path';
+import v4 from 'uuid';
+
+import FsContainer, { BitExecOption } from './container';
+import ContainerExec from './container-exec';
+
+export default class Capsule extends CapsuleTemplate<Exec, NodeFS> {
+  private _wrkDir: string;
+  constructor(
+    /**
+     * container implementation the capsule is being executed within.
+     */
+    protected container: FsContainer,
+    /**
+     * the capsule's file system.
+     */
+    readonly fs: NodeFS,
+    /**
+     * console for controlling process streams as stdout, stdin and stderr.
+     */
+    readonly console: Console = new Console(),
+    /**
+     * capsule's state.
+     */
+    readonly state: State,
+    readonly component: Component
+  ) {
+    super(container, fs, console, state);
+    this._wrkDir = container.wrkDir;
+  }
+
+  /**
+   * @deprecated please use `this.path`
+   */
+  get wrkDir(): string {
+    return this.path;
+  }
+
+  get path(): string {
+    return realpathSync(this._wrkDir);
+  }
+
+  start(): Promise<any> {
+    return this.container.start();
+  }
+
+  async execNode(executable: string, args: any, exec: ContainerExec) {
+    return this.typedExec(
+      {
+        command: ['node', executable, ...(args.args || [])],
+        cwd: '',
+      },
+      exec
+    );
+  }
+
+  async typedExec(opts: BitExecOption, exec = new ContainerExec()) {
+    return this.container.exec(opts, exec);
+  }
+
+  outputFile(file: string, data: any, options?: any): Promise<any> {
+    return this.container.outputFile(file, data, options);
+  }
+
+  removePath(dir: string): Promise<any> {
+    return this.container.removePath(dir);
+  }
+
+  symlink(src: string, dest: string): Promise<any> {
+    return this.container.symlink(src, dest);
+  }
+
+  // TODO: refactor this crap and simplify capsule API
+  async execute(cmd: string, options?: Record<string, any> | null | undefined) {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    const execResults = await this.exec({ command: cmd.split(' '), options });
+    let stdout = '';
+    let stderr = '';
+    return new Promise((resolve, reject) => {
+      execResults.stdout.on('data', (data: string) => {
+        stdout += data;
+      });
+      execResults.stdout.on('error', (error: string) => {
+        return reject(error);
+      });
+      // @ts-ignore
+      execResults.on('close', () => {
+        return resolve({ stdout, stderr });
+      });
+      execResults.stderr.on('error', (error: string) => {
+        return reject(error);
+      });
+      execResults.stderr.on('data', (data: string) => {
+        stderr += data;
+      });
+    });
+  }
+
+  /**
+   * @todo: fix.
+   * it skips the capsule fs because for some reason `capsule.fs.promises.readdir` doesn't work
+   * the same as `capsule.fs.readdir` and it doesn't have the capsule dir as pwd.
+   *
+   * returns the paths inside the capsule
+   */
+  getAllFilesPaths(dir = '.', options: { ignore?: string[] } = {}) {
+    const files = glob.sync('**', { cwd: path.join(this.path, dir), nodir: true, ...options });
+    return files.map((file) => path.join(dir, file));
+  }
+
+  static getCapsuleDirName(component: Component, config: { alwaysNew?: boolean; name?: string } = {}) {
+    return config.name || filenamify(component.id.toString(), { replacement: '_' });
+  }
+
+  static getCapsuleRootDir(component: Component, baseDir: string, config: { alwaysNew?: boolean; name?: string } = {}) {
+    return path.join(baseDir, Capsule.getCapsuleDirName(component, config));
+  }
+
+  static async createFromComponent(
+    component: Component,
+    baseDir: string,
+    config: { alwaysNew?: boolean; name?: string } = {}
+  ): Promise<Capsule> {
+    // TODO: make this a static method and combine with ComponentCapsule
+    const capsuleDirName = Capsule.getCapsuleDirName(component, config);
+    const wrkDir = path.join(baseDir, config.alwaysNew ? `${capsuleDirName}_${v4()}` : capsuleDirName);
+    const container = new FsContainer(wrkDir);
+    const capsule = new Capsule(container, container.fs, new Console(), new State(), component);
+    await capsule.start();
+    return capsule;
+  }
+}

package/capsule/container-exec.ts

@@ -0,0 +1,31 @@
+import { DuplexBufferStream, Exec, ExecStatus } from '@teambit/capsule';
+import { EventEmitter } from 'events';
+
+export default class ContainerExec extends EventEmitter implements Exec {
+  constructor(private _code: number = 0) {
+    super();
+  }
+
+  stdout: DuplexBufferStream = new DuplexBufferStream();
+  stderr: DuplexBufferStream = new DuplexBufferStream();
+  stdin: DuplexBufferStream = new DuplexBufferStream();
+
+  setStatus(status: number): void {
+    this._code = status;
+    this.emit('close');
+  }
+
+  get code(): number {
+    return this._code;
+  }
+
+  inspect(): Promise<ExecStatus> {
+    return Promise.resolve({
+      running: true,
+      pid: 1,
+    });
+  }
+  abort(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+}

package/capsule/container.ts

@@ -0,0 +1,128 @@
+import { AnyFS, NodeFS } from '@teambit/any-fs';
+import { Container, ContainerFactoryOptions, ContainerStatus, Exec, ExecOptions } from '@teambit/capsule';
+import execa from 'execa';
+import fs from 'fs-extra';
+import * as path from 'path';
+import { Stream } from 'stream';
+
+import ContainerExec from './container-exec';
+
+const debug = require('debug')('fs-container');
+
+export interface BitExecOption extends ExecOptions {
+  cwd: string;
+  stdio?: 'pipe' | 'ipc' | 'ignore' | 'inherit' | Stream | number | undefined;
+}
+export interface BitContainerConfig extends ContainerFactoryOptions {
+  other?: string;
+}
+
+export default class FsContainer implements Container<Exec, AnyFS> {
+  id = 'FS Container';
+
+  fs: NodeFS = new NodeFS(this.wrkDir);
+
+  constructor(readonly wrkDir: string) {}
+
+  // TODO: do we need this?
+  public getPath() {
+    return this.wrkDir;
+  }
+
+  private composePath(pathToCompose) {
+    return path.join(this.getPath(), pathToCompose);
+  }
+
+  outputFile(file, data, options) {
+    const filePath = this.composePath(file);
+    debug(`writing file on ${filePath}`);
+    return fs.outputFile(filePath, data, options);
+  }
+
+  removePath(dir: string): Promise<any> {
+    const pathToRemove = this.composePath(dir);
+    return fs.remove(pathToRemove);
+  }
+
+  async symlink(src: string, dest: string): Promise<any> {
+    const srcPath = this.composePath(src);
+    const destPath = this.composePath(dest);
+    await fs.ensureDir(path.dirname(destPath));
+    return fs.ensureSymlink(srcPath, destPath);
+  }
+
+  async exec(execOptions: BitExecOption, exec = new ContainerExec()): Promise<ContainerExec> {
+    const cwd = execOptions.cwd ? this.composePath(execOptions.cwd) : this.getPath();
+    debug(`executing the following command: ${execOptions.command.join(' ')}, on cwd: ${cwd}`);
+    const subprocessP = execa.command(execOptions.command.join(' '), {
+      shell: true,
+      cwd,
+      stdio: ['ipc'],
+    });
+
+    // @TODO: FIX! This probably causes errors ad the promise is not handled properly!
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    subprocessP.on('message', function (msg: any) {
+      exec.emit('message', msg);
+    });
+    /* eslint-disable @typescript-eslint/no-non-null-assertion */
+    subprocessP.stderr?.pipe(exec.stderr);
+    subprocessP.stdout?.pipe(exec.stdout);
+    ['close', 'exit'].forEach(function (eventName: string) {
+      // @TODO: FIX! This probably causes errors ad the promise is not handled properly!
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      subprocessP.on(eventName, function (statusCode) {
+        exec.setStatus(statusCode);
+      });
+    });
+
+    return exec;
+  }
+
+  async execP(execOptions: BitExecOption): Promise<string> {
+    let hasError = false;
+    const exec = await this.exec(execOptions);
+    return new Promise((resolve, reject) => {
+      exec.stdout.on('error', () => {
+        hasError = true;
+      });
+      exec.on('close', () => {
+        if (hasError) reject(exec.stderr.getContents!(exec.stderr.size).toString());
+        resolve(exec.stdout.getContents!(exec.stdout.size).toString());
+      });
+    });
+  }
+
+  async terminal() {
+    const cwd = this.getPath();
+    return execa.command(process.env.SHELL || '/bin/zsh', { cwd, stdio: 'inherit' });
+  }
+
+  start(): Promise<void> {
+    return fs.ensureDir(this.wrkDir);
+  }
+  // @ts-ignore
+  async inspect(): Promise<ContainerStatus> {
+    // todo: probably not needed for this container
+  }
+  async pause(): Promise<void> {
+    // do nothing
+  }
+  async resume(): Promise<void> {
+    // do nothing
+  }
+  // eslint-disable-next-line
+  stop(ttl?: number | undefined): Promise<void> {
+    return fs.remove(this.wrkDir);
+  }
+  async destroy(): Promise<void> {
+    await this.stop();
+  }
+  log(): Promise<Exec> {
+    throw new Error('Method not implemented.');
+  }
+  on(event: string, fn: (data: any) => void): void {
+    return fn(event);
+    // throw new Error('Method not implemented.');
+  }
+}

package/capsule/index.ts

@@ -0,0 +1,3 @@
+export { default as Capsule } from './capsule';
+export { default as FsContainer } from './container';
+export { default as ContainerExec } from './container-exec';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/isolator",
-  "version": "0.0.566",
+  "version": "0.0.570",
   "homepage": "https://bit.dev/teambit/component/isolator",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "isolator",
-    "version": "0.0.566"
+    "version": "0.0.570"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -23,14 +23,14 @@
     "execa": "2.1.0",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/component": "0.0.566",
-    "@teambit/legacy-bit-id": "0.0.382",
-    "@teambit/cli": "0.0.393",
-    "@teambit/component-package-version": "0.0.379",
-    "@teambit/dependency-resolver": "0.0.566",
-    "@teambit/global-config": "0.0.394",
-    "@teambit/graph": "0.0.566",
-    "@teambit/logger": "0.0.478"
+    "@teambit/component": "0.0.570",
+    "@teambit/legacy-bit-id": "0.0.384",
+    "@teambit/cli": "0.0.395",
+    "@teambit/component-package-version": "0.0.381",
+    "@teambit/dependency-resolver": "0.0.570",
+    "@teambit/global-config": "0.0.396",
+    "@teambit/graph": "0.0.570",
+    "@teambit/logger": "0.0.482"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",
@@ -45,7 +45,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.179",
+    "@teambit/legacy": "1.0.181",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -73,27 +73,12 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.179",
+        "@teambit/legacy": "1.0.181",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
-  "files": [
-    "dist",
-    "!dist/tsconfig.tsbuildinfo",
-    "**/*.md",
-    "**/*.mdx",
-    "**/*.js",
-    "**/*.json",
-    "**/*.sass",
-    "**/*.scss",
-    "**/*.less",
-    "**/*.css",
-    "**/*.css",
-    "**/*.jpeg",
-    "**/*.gif"
-  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  const src: string;
+  export default src;
+}
+
+// @TODO Gilad
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}