@atlaspack/core 2.12.1-canary.3354

package/lib/UncommittedAsset.js

@@ -0,0 +1,342 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _serializer = require("./serializer");
+var _Dependency = require("./Dependency");
+var _Environment = require("./Environment");
+var _constants = require("./constants");
+var _assetUtils = require("./assetUtils");
+var _types = require("./types");
+var _utils2 = require("./utils");
+var _projectPath = require("./projectPath");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class UncommittedAsset {
+  constructor({
+    value,
+    options,
+    content,
+    mapBuffer,
+    ast,
+    isASTDirty,
+    idBase,
+    invalidations
+  }) {
+    this.value = value;
+    this.options = options;
+    this.content = content;
+    this.mapBuffer = mapBuffer;
+    this.ast = ast;
+    this.isASTDirty = isASTDirty || false;
+    this.idBase = idBase;
+    this.invalidations = invalidations || (0, _utils2.createInvalidations)();
+  }
+
+  /*
+   * Prepares the asset for being serialized to the cache by committing its
+   * content and map of the asset to the cache.
+   */
+  async commit() {
+    // If there is a dirty AST, clear out any old content and map as these
+    // must be regenerated later and shouldn't be committed.
+    if (this.ast != null && this.isASTDirty) {
+      this.content = null;
+      this.mapBuffer = null;
+    }
+    let size = 0;
+    let outputHash = '';
+    let contentKey = this.content == null ? null : this.getCacheKey('content');
+    let mapKey = this.mapBuffer == null ? null : this.getCacheKey('map');
+    let astKey = this.ast == null ? null : this.getCacheKey('ast');
+
+    // Since we can only read from the stream once, compute the content length
+    // and hash while it's being written to the cache.
+    await Promise.all([contentKey != null && this.commitContent(contentKey).then(s => (size = s.size, outputHash = s.hash)), this.mapBuffer != null && mapKey != null && this.options.cache.setBlob(mapKey, this.mapBuffer), astKey != null && this.options.cache.setBlob(astKey, (0, _serializer.serializeRaw)(this.ast))]);
+    this.value.contentKey = contentKey;
+    this.value.mapKey = mapKey;
+    this.value.astKey = astKey;
+    this.value.outputHash = outputHash;
+    if (this.content != null) {
+      this.value.stats.size = size;
+    }
+    this.value.isLargeBlob = this.content instanceof _stream().Readable;
+    this.value.committed = true;
+  }
+  async commitContent(contentKey) {
+    let content = await this.content;
+    if (content == null) {
+      return {
+        size: 0,
+        hash: ''
+      };
+    }
+    let size = 0;
+    if (content instanceof _stream().Readable) {
+      let hash = new (_rust().Hash)();
+      await this.options.cache.setStream(contentKey, content.pipe(new (_utils().TapStream)(buf => {
+        hash.writeBuffer(buf);
+        size += buf.length;
+      })));
+      return {
+        size,
+        hash: hash.finish()
+      };
+    }
+    let hash;
+    if (typeof content === 'string') {
+      hash = (0, _rust().hashString)(content);
+      size = Buffer.byteLength(content);
+    } else {
+      hash = (0, _rust().hashBuffer)(content);
+      size = content.length;
+    }
+    await this.options.cache.setBlob(contentKey, content);
+    return {
+      size,
+      hash
+    };
+  }
+  async getCode() {
+    if (this.ast != null && this.isASTDirty) {
+      throw new Error('Cannot call getCode() on an asset with a dirty AST. For transformers, implement canReuseAST() and check asset.isASTDirty.');
+    }
+    let content = await this.content;
+    if (typeof content === 'string' || content instanceof Buffer) {
+      return content.toString();
+    } else if (content != null) {
+      this.content = (0, _utils().bufferStream)(content);
+      return (await this.content).toString();
+    }
+    (0, _assert().default)(false, 'Internal error: missing content');
+  }
+  async getBuffer() {
+    let content = await this.content;
+    if (content == null) {
+      return Buffer.alloc(0);
+    } else if (content instanceof Buffer) {
+      return content;
+    } else if (typeof content === 'string') {
+      return Buffer.from(content);
+    }
+    this.content = (0, _utils().bufferStream)(content);
+    return this.content;
+  }
+  getStream() {
+    if (this.content instanceof _stream().Readable) {
+      // Remove content if it's a stream, as it should not be reused.
+      let content = this.content;
+      this.content = null;
+      return content;
+    }
+    if (this.content instanceof Promise) {
+      return (0, _utils().streamFromPromise)(this.content);
+    }
+    return (0, _utils().blobToStream)(this.content ?? Buffer.alloc(0));
+  }
+  setCode(code) {
+    this.content = code;
+    this.clearAST();
+  }
+  setBuffer(buffer) {
+    this.content = buffer;
+    this.clearAST();
+  }
+  setStream(stream) {
+    this.content = stream;
+    this.clearAST();
+  }
+  async loadExistingSourcemap() {
+    if (this.map) {
+      return this.map;
+    }
+    let code = await this.getCode();
+    let map = await (0, _utils().loadSourceMap)((0, _projectPath.fromProjectPath)(this.options.projectRoot, this.value.filePath), code, {
+      fs: this.options.inputFS,
+      projectRoot: this.options.projectRoot
+    });
+    if (map) {
+      this.map = map;
+      this.mapBuffer = map.toBuffer();
+      this.setCode(code.replace(_utils().SOURCEMAP_RE, ''));
+    }
+    return this.map;
+  }
+  getMapBuffer() {
+    return Promise.resolve(this.mapBuffer);
+  }
+  async getMap() {
+    if (this.map == null) {
+      let mapBuffer = this.mapBuffer ?? (await this.getMapBuffer());
+      if (mapBuffer) {
+        // Get sourcemap from flatbuffer
+        this.map = new (_sourceMap().default)(this.options.projectRoot, mapBuffer);
+      }
+    }
+    return this.map;
+  }
+  setMap(map) {
+    var _this$map;
+    // If we have sourceContent available, it means this asset is source code without
+    // a previous source map. Ensure that the map set by the transformer has the original
+    // source content available.
+    if (map != null && this.sourceContent != null) {
+      map.setSourceContent((0, _projectPath.fromProjectPath)(this.options.projectRoot, this.value.filePath),
+      // $FlowFixMe
+      this.sourceContent);
+      this.sourceContent = null;
+    }
+    this.map = map;
+    this.mapBuffer = (_this$map = this.map) === null || _this$map === void 0 ? void 0 : _this$map.toBuffer();
+  }
+  getAST() {
+    return Promise.resolve(this.ast);
+  }
+  setAST(ast) {
+    this.ast = ast;
+    this.isASTDirty = true;
+    this.value.astGenerator = {
+      type: ast.type,
+      version: ast.version
+    };
+  }
+  clearAST() {
+    this.ast = null;
+    this.isASTDirty = false;
+    this.value.astGenerator = null;
+  }
+  getCacheKey(key) {
+    return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + key + this.value.id);
+  }
+  addDependency(opts) {
+    // eslint-disable-next-line no-unused-vars
+    let {
+      env,
+      symbols,
+      ...rest
+    } = opts;
+    let dep = (0, _Dependency.createDependency)(this.options.projectRoot, {
+      ...rest,
+      // $FlowFixMe "convert" the $ReadOnlyMaps to the interal mutable one
+      symbols,
+      env: (0, _Environment.mergeEnvironments)(this.options.projectRoot, this.value.env, env),
+      sourceAssetId: this.value.id,
+      sourcePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, this.value.filePath)
+    });
+    let existing = this.value.dependencies.get(dep.id);
+    if (existing) {
+      (0, _Dependency.mergeDependencies)(existing, dep);
+    } else {
+      this.value.dependencies.set(dep.id, dep);
+    }
+    return dep.id;
+  }
+  invalidateOnFileChange(filePath) {
+    this.invalidations.invalidateOnFileChange.add(filePath);
+  }
+  invalidateOnFileCreate(invalidation) {
+    this.invalidations.invalidateOnFileCreate.push((0, _utils2.invalidateOnFileCreateToInternal)(this.options.projectRoot, invalidation));
+  }
+  invalidateOnEnvChange(key) {
+    this.invalidations.invalidateOnEnvChange.add(key);
+  }
+  invalidateOnBuild() {
+    this.invalidations.invalidateOnBuild = true;
+  }
+  invalidateOnStartup() {
+    this.invalidations.invalidateOnStartup = true;
+  }
+  getDependencies() {
+    return Array.from(this.value.dependencies.values());
+  }
+  createChildAsset(result, plugin, configPath, configKeyPath) {
+    let content = result.content ?? null;
+    let asset = new UncommittedAsset({
+      value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
+        idBase: this.idBase,
+        filePath: this.value.filePath,
+        type: result.type,
+        bundleBehavior: result.bundleBehavior ?? (this.value.bundleBehavior == null ? null : _types.BundleBehaviorNames[this.value.bundleBehavior]),
+        isBundleSplittable: result.isBundleSplittable ?? this.value.isBundleSplittable,
+        isSource: this.value.isSource,
+        env: (0, _Environment.mergeEnvironments)(this.options.projectRoot, this.value.env, result.env),
+        dependencies: this.value.type === result.type ? new Map(this.value.dependencies) : new Map(),
+        meta: {
+          ...this.value.meta,
+          ...result.meta
+        },
+        pipeline: result.pipeline ?? (this.value.type === result.type ? this.value.pipeline : null),
+        stats: {
+          time: 0,
+          size: this.value.stats.size
+        },
+        // $FlowFixMe
+        symbols: result.symbols,
+        sideEffects: result.sideEffects ?? this.value.sideEffects,
+        uniqueKey: result.uniqueKey,
+        astGenerator: result.ast ? {
+          type: result.ast.type,
+          version: result.ast.version
+        } : null,
+        plugin,
+        configPath,
+        configKeyPath
+      }),
+      options: this.options,
+      content,
+      ast: result.ast,
+      isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
+      mapBuffer: result.map ? result.map.toBuffer() : null,
+      idBase: this.idBase,
+      invalidations: this.invalidations
+    });
+    let dependencies = result.dependencies;
+    if (dependencies) {
+      for (let dep of dependencies) {
+        asset.addDependency(dep);
+      }
+    }
+    return asset;
+  }
+  updateId() {
+    // $FlowFixMe - this is fine
+    this.value.id = (0, _assetUtils.createAssetIdFromOptions)(this.value);
+  }
+}
+exports.default = UncommittedAsset;

package/lib/Validation.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));
+var _assetUtils = require("./assetUtils");
+var _Asset = require("./public/Asset");
+var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
+var _summarizeRequest = _interopRequireDefault(require("./summarizeRequest"));
+var _projectPath = require("./projectPath");
+function _profiler() {
+  const data = require("@atlaspack/profiler");
+  _profiler = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class Validation {
+  allAssets = {};
+  allValidators = {};
+  constructor({
+    config,
+    dedicatedThread,
+    options,
+    requests,
+    report,
+    workerApi
+  }) {
+    this.dedicatedThread = dedicatedThread ?? false;
+    this.options = options;
+    this.atlaspackConfig = config;
+    this.report = report;
+    this.requests = requests;
+    this.workerApi = workerApi;
+  }
+  async run() {
+    let pluginOptions = new _PluginOptions.default(this.options);
+    await this.buildAssetsAndValidators();
+    await Promise.all(Object.keys(this.allValidators).map(async validatorName => {
+      let assets = this.allAssets[validatorName];
+      if (assets) {
+        let plugin = this.allValidators[validatorName];
+        let validatorLogger = new (_logger().PluginLogger)({
+          origin: validatorName
+        });
+        let validatorTracer = new (_profiler().PluginTracer)({
+          origin: validatorName,
+          category: 'validator'
+        });
+        let validatorResults = [];
+        try {
+          // If the plugin supports the single-threading validateAll method, pass all assets to it.
+          if (plugin.validateAll && this.dedicatedThread) {
+            validatorResults = await plugin.validateAll({
+              assets: assets.map(asset => new _Asset.Asset(asset)),
+              options: pluginOptions,
+              logger: validatorLogger,
+              tracer: validatorTracer,
+              resolveConfigWithPath: (configNames, assetFilePath) => (0, _utils().resolveConfig)(this.options.inputFS, assetFilePath, configNames, this.options.projectRoot)
+            });
+          }
+
+          // Otherwise, pass the assets one-at-a-time
+          else if (plugin.validate && !this.dedicatedThread) {
+            await Promise.all(assets.map(async input => {
+              let config = null;
+              let publicAsset = new _Asset.Asset(input);
+              if (plugin.getConfig) {
+                config = await plugin.getConfig({
+                  asset: publicAsset,
+                  options: pluginOptions,
+                  logger: validatorLogger,
+                  tracer: validatorTracer,
+                  resolveConfig: configNames => (0, _utils().resolveConfig)(this.options.inputFS, publicAsset.filePath, configNames, this.options.projectRoot)
+                });
+              }
+              let validatorResult = await plugin.validate({
+                asset: publicAsset,
+                options: pluginOptions,
+                config,
+                logger: validatorLogger,
+                tracer: validatorTracer
+              });
+              validatorResults.push(validatorResult);
+            }));
+          }
+          this.handleResults(validatorResults);
+        } catch (e) {
+          throw new (_diagnostic().default)({
+            diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+              origin: validatorName
+            })
+          });
+        }
+      }
+    }));
+  }
+  async buildAssetsAndValidators() {
+    // Figure out what validators need to be run, and group the assets by the relevant validators.
+    await Promise.all(this.requests.map(async request => {
+      this.report({
+        type: 'validation',
+        filePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, request.filePath)
+      });
+      let asset = await this.loadAsset(request);
+      let validators = await this.atlaspackConfig.getValidators(request.filePath);
+      for (let validator of validators) {
+        this.allValidators[validator.name] = validator.plugin;
+        if (this.allAssets[validator.name]) {
+          this.allAssets[validator.name].push(asset);
+        } else {
+          this.allAssets[validator.name] = [asset];
+        }
+      }
+    }));
+  }
+  handleResults(validatorResults) {
+    let warnings = [];
+    let errors = [];
+    validatorResults.forEach(result => {
+      if (result) {
+        warnings.push(...result.warnings);
+        errors.push(...result.errors);
+      }
+    });
+    if (errors.length > 0) {
+      throw new (_diagnostic().default)({
+        diagnostic: errors
+      });
+    }
+    if (warnings.length > 0) {
+      _logger().default.warn(warnings);
+    }
+  }
+  async loadAsset(request) {
+    let {
+      filePath,
+      env,
+      code,
+      sideEffects,
+      query
+    } = request;
+    let {
+      content,
+      size,
+      isSource
+    } = await (0, _summarizeRequest.default)(this.options.inputFS, {
+      filePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, request.filePath)
+    });
+
+    // If the transformer request passed code rather than a filename,
+    // use a hash as the base for the id to ensure it is unique.
+    let idBase = code != null ? (0, _rust().hashString)(code) : (0, _projectPath.fromProjectPathRelative)(filePath);
+    return new _UncommittedAsset.default({
+      idBase,
+      value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
+        idBase,
+        filePath: filePath,
+        isSource,
+        type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),
+        query,
+        env: env,
+        stats: {
+          time: 0,
+          size
+        },
+        sideEffects: sideEffects
+      }),
+      options: this.options,
+      content
+    });
+  }
+}
+exports.default = Validation;