@atlaspack/core 2.12.1-canary.3456 → 2.12.1-canary.3457

package/lib/Atlaspack.js

@@ -187,7 +187,7 @@ class Atlaspack {
         threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
-        fs: inputFS && (0, _atlaspackV.toFileSystemV3)(inputFS),
+        fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
         defaultTargetOptions: {
           // $FlowFixMe projectPath is just a string
           distDir: resolvedOptions.defaultTargetOptions.distDir,

package/lib/atlaspack-v3/fs.js

@@ -3,35 +3,37 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toFileSystemV3 = toFileSystemV3;
+exports.FileSystemV3 = void 0;
 var _jsCallable = require("./jsCallable");
-// Move to @atlaspack/utils or a dedicated v3 / migration package later
-function toFileSystemV3(fs) {
-  return {
-    canonicalize: (0, _jsCallable.jsCallable)(path => fs.realpathSync(path)),
-    createDirectory: (0, _jsCallable.jsCallable)(path => fs.mkdirp(path)),
-    cwd: (0, _jsCallable.jsCallable)(() => fs.cwd()),
-    readFile: (0, _jsCallable.jsCallable)((path, encoding) => {
-      if (!encoding) {
-        // $FlowFixMe
-        return [...fs.readFileSync(path)];
-      } else {
-        return fs.readFileSync(path, encoding);
-      }
-    }),
-    isFile: path => {
-      try {
-        return fs.statSync(path).isFile();
-      } catch {
-        return false;
-      }
-    },
-    isDir: path => {
-      try {
-        return fs.statSync(path).isDirectory();
-      } catch {
-        return false;
-      }
+class FileSystemV3 {
+  #fs;
+  constructor(fs) {
+    this.#fs = fs;
+  }
+  canonicalize = (0, _jsCallable.jsCallable)(path => this.#fs.realpathSync(path));
+  createDirectory = (0, _jsCallable.jsCallable)(path => this.#fs.mkdirp(path));
+  cwd = (0, _jsCallable.jsCallable)(() => this.#fs.cwd());
+  isFile = path => {
+    try {
+      return this.#fs.statSync(path).isFile();
+    } catch {
+      return false;
     }
   };
-}
+  isDir = path => {
+    try {
+      return this.#fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  readFile = (0, _jsCallable.jsCallable)((path, encoding) => {
+    if (!encoding) {
+      // $FlowFixMe
+      return [...this.#fs.readFileSync(path)];
+    } else {
+      return this.#fs.readFileSync(path, encoding);
+    }
+  });
+}
+exports.FileSystemV3 = FileSystemV3;

package/lib/atlaspack-v3/index.js

@@ -9,10 +9,10 @@ Object.defineProperty(exports, "AtlaspackV3", {
     return _AtlaspackV.AtlaspackV3;
   }
 });
-Object.defineProperty(exports, "toFileSystemV3", {
+Object.defineProperty(exports, "FileSystemV3", {
   enumerable: true,
   get: function () {
-    return _fs.toFileSystemV3;
+    return _fs.FileSystemV3;
   }
 });
 var _fs = require("./fs");

package/lib/atlaspack-v3/jsCallable.js

@@ -5,11 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.jsCallable = jsCallable;
 function jsCallable(fn) {
-  return (...args) => {
+  return async (...args) => {
     try {
-      return fn(...args);
-    } catch (err) {
-      return err;
+      // $FlowFixMe "await" is needed to log the error from
+      // Promises and is safe to use on non-promises
+      return await fn(...args);
+      // $FlowFixMe
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      throw error;
     }
   };
 }

package/lib/atlaspack-v3/worker/worker.js

@@ -249,11 +249,9 @@ class AtlaspackWorker {
         type: mutableAsset.type,
         code: Array.from(await mutableAsset.getBuffer()),
         meta: mutableAsset.meta,
-        // $FlowFixMe TODO Rust does not accept an undefined pipeline
         pipeline: mutableAsset.pipeline,
         query: mutableAsset.query.toString(),
         symbols: mutableAsset.symbols.intoNapi(),
-        // $FlowFixMe TODO Rust does not accept an undefined pipeline
         uniqueKey: mutableAsset.uniqueKey,
         sideEffects: mutableAsset.sideEffects,
         isBundleSplittable: mutableAsset.isBundleSplittable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3456+e7cf40eae",
+  "version": "2.12.1-canary.3457+9b872e432",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/diagnostic": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/events": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/feature-flags": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/fs": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/graph": "3.2.1-canary.3456+e7cf40eae",
-    "@atlaspack/logger": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/package-manager": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/plugin": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/profiler": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/rust": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/types": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/utils": "2.12.1-canary.3456+e7cf40eae",
-    "@atlaspack/workers": "2.12.1-canary.3456+e7cf40eae",
+    "@atlaspack/cache": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/diagnostic": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/events": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/feature-flags": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/fs": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/graph": "3.2.1-canary.3457+9b872e432",
+    "@atlaspack/logger": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/package-manager": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/plugin": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/profiler": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/rust": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/types": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/utils": "2.12.1-canary.3457+9b872e432",
+    "@atlaspack/workers": "2.12.1-canary.3457+9b872e432",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "e7cf40eaee44c132a8345052b6e7a9b5a6c3545b"
+  "gitHead": "9b872e432000b9fc618db3fa0a13dbab0e7431ee"
 }

package/src/Atlaspack.js

@@ -58,7 +58,7 @@ import {
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
 import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
-import {AtlaspackV3, toFileSystemV3} from './atlaspack-v3';
+import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 
 registerCoreWithSerializer();
 
@@ -144,7 +144,7 @@ export default class Atlaspack {
           ? undefined
           : [entries],
         env: resolvedOptions.env,
-        fs: inputFS && toFileSystemV3(inputFS),
+        fs: inputFS && new FileSystemV3(inputFS),
         defaultTargetOptions: {
           // $FlowFixMe projectPath is just a string
           distDir: resolvedOptions.defaultTargetOptions.distDir,

package/src/atlaspack-v3/fs.js

@@ -1,6 +1,6 @@
 // @flow strict-local
 
-import type {FileSystem} from '@atlaspack/rust';
+import type {FileSystem, JsCallable} from '@atlaspack/rust';
 import type {
   Encoding,
   FilePath,
@@ -9,33 +9,47 @@ import type {
 
 import {jsCallable} from './jsCallable';
 
-// Move to @atlaspack/utils or a dedicated v3 / migration package later
-export function toFileSystemV3(fs: ClassicFileSystem): FileSystem {
-  return {
-    canonicalize: jsCallable((path: FilePath) => fs.realpathSync(path)),
-    createDirectory: jsCallable((path: FilePath) => fs.mkdirp(path)),
-    cwd: jsCallable(() => fs.cwd()),
-    readFile: jsCallable((path: string, encoding?: Encoding) => {
+export class FileSystemV3 implements FileSystem {
+  #fs: ClassicFileSystem;
+
+  constructor(fs: ClassicFileSystem) {
+    this.#fs = fs;
+  }
+
+  canonicalize: JsCallable<[FilePath], FilePath> = jsCallable(
+    (path: FilePath) => this.#fs.realpathSync(path),
+  );
+
+  createDirectory: JsCallable<[FilePath], Promise<void>> = jsCallable(
+    (path: FilePath) => this.#fs.mkdirp(path),
+  );
+
+  cwd: JsCallable<[], FilePath> = jsCallable(() => this.#fs.cwd());
+
+  isFile: JsCallable<[FilePath], boolean> = (path: string) => {
+    try {
+      return this.#fs.statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  };
+
+  isDir: JsCallable<[FilePath], boolean> = (path: string) => {
+    try {
+      return this.#fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+
+  readFile: JsCallable<[FilePath, Encoding], string> = jsCallable(
+    (path: string, encoding?: Encoding) => {
       if (!encoding) {
         // $FlowFixMe
-        return [...fs.readFileSync(path)];
+        return [...this.#fs.readFileSync(path)];
       } else {
-        return fs.readFileSync(path, encoding);
-      }
-    }),
-    isFile: (path: string) => {
-      try {
-        return fs.statSync(path).isFile();
-      } catch {
-        return false;
+        return this.#fs.readFileSync(path, encoding);
       }
     },
-    isDir: (path: string) => {
-      try {
-        return fs.statSync(path).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-  };
+  );
 }

package/src/atlaspack-v3/index.js

@@ -1,5 +1,5 @@
 // @flow
 
-export {toFileSystemV3} from './fs';
+export {FileSystemV3} from './fs';
 export {AtlaspackV3} from './AtlaspackV3';
 export type * from './AtlaspackV3';

package/src/atlaspack-v3/jsCallable.js

@@ -1,17 +1,18 @@
 // @flow strict-local
 
-export type JsCallable<Args: $ReadOnlyArray<mixed>, Return> = (
-  ...Args
-) => Return;
-
 export function jsCallable<Args: $ReadOnlyArray<mixed>, Return>(
-  fn: (...Args) => Return,
-): (...Args) => Return {
-  return (...args: Args) => {
+  fn: (...Args) => Return | Promise<Return>,
+): (...Args) => Promise<Return> {
+  return async (...args: Args): Promise<Return> => {
     try {
-      return fn(...args);
-    } catch (err) {
-      return err;
+      // $FlowFixMe "await" is needed to log the error from
+      // Promises and is safe to use on non-promises
+      return await fn(...args);
+      // $FlowFixMe
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      throw error;
     }
   };
 }

package/src/atlaspack-v3/worker/worker.js

@@ -1,6 +1,7 @@
 // @flow
 import assert from 'assert';
 import * as napi from '@atlaspack/rust';
+import type {JsCallable} from '@atlaspack/rust';
 import {NodeFS} from '@atlaspack/fs';
 import {NodePackageManager} from '@atlaspack/package-manager';
 import type {
@@ -24,7 +25,6 @@ import {
   dependencyPriorityMap,
 } from './compat';
 import {jsCallable} from '../jsCallable';
-import type {JsCallable} from '../jsCallable';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -256,11 +256,9 @@ export class AtlaspackWorker {
           type: mutableAsset.type,
           code: Array.from(await mutableAsset.getBuffer()),
           meta: mutableAsset.meta,
-          // $FlowFixMe TODO Rust does not accept an undefined pipeline
           pipeline: mutableAsset.pipeline,
           query: mutableAsset.query.toString(),
           symbols: mutableAsset.symbols.intoNapi(),
-          // $FlowFixMe TODO Rust does not accept an undefined pipeline
           uniqueKey: mutableAsset.uniqueKey,
           sideEffects: mutableAsset.sideEffects,
           isBundleSplittable: mutableAsset.isBundleSplittable,