@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/UncommittedAsset.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const stream_1 = require("stream");
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const utils_1 = require("@atlaspack/utils");
+const rust_1 = require("@atlaspack/rust");
+const Dependency_1 = require("./Dependency");
+const Environment_1 = require("./Environment");
+const constants_1 = require("./constants");
+const assetUtils_1 = require("./assetUtils");
+const types_1 = require("./types");
+const utils_2 = require("./utils");
+const projectPath_1 = require("./projectPath");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+class UncommittedAsset {
+    constructor({ value, options, content, mapBuffer, ast, isASTDirty, code, invalidations, }) {
+        this.value = value;
+        this.options = options;
+        this.content = content;
+        this.mapBuffer = mapBuffer;
+        this.ast = ast;
+        this.isASTDirty = isASTDirty || false;
+        this.code = code;
+        this.invalidations = invalidations || (0, utils_2.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, build_cache_1.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_1.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_1.Readable) {
+            let hash = new rust_1.Hash();
+            await this.options.cache.setStream(contentKey, content.pipe(
+            // @ts-expect-error TS2554
+            new utils_1.TapStream((buf) => {
+                hash.writeBuffer(buf);
+                size += buf.length;
+            })));
+            return { size, hash: hash.finish() };
+        }
+        let hash;
+        if (typeof content === 'string') {
+            hash = (0, rust_1.hashString)(content);
+            size = Buffer.byteLength(content);
+        }
+        else {
+            hash = (0, rust_1.hashBuffer)(content);
+            size = content.length;
+        }
+        // Maybe we should just store this in a file instead of LMDB
+        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) {
+            // @ts-expect-error TS2345
+            this.content = (0, utils_1.bufferStream)(content);
+            return (await this.content).toString();
+        }
+        (0, assert_1.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);
+        }
+        // @ts-expect-error TS2345
+        this.content = (0, utils_1.bufferStream)(content);
+        return this.content;
+    }
+    getStream() {
+        if (this.content instanceof stream_1.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_1.streamFromPromise)(this.content);
+        }
+        return (0, utils_1.blobToStream)(this.content ?? Buffer.alloc(0));
+    }
+    setCode(code) {
+        this.content = code;
+        this.clearAST();
+    }
+    setBuffer(buffer) {
+        this.content = buffer;
+        this.clearAST();
+    }
+    /**
+     * @deprecated This has been broken on any cache other than FSCache for a long time.
+     */
+    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_1.loadSourceMap)((0, projectPath_1.fromProjectPath)(this.options.projectRoot, this.value.filePath), code, {
+            fs: this.options.inputFS,
+            projectRoot: this.options.projectRoot,
+        });
+        if (map) {
+            this.map = map;
+            this.mapBuffer = source_map_1.default.safeToBuffer(map);
+            this.setCode(code.replace(utils_1.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 source_map_1.default(this.options.projectRoot, mapBuffer);
+            }
+        }
+        return this.map;
+    }
+    setMap(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_1.fromProjectPath)(this.options.projectRoot, this.value.filePath), this.sourceContent);
+            this.sourceContent = null;
+        }
+        this.map = map;
+        this.mapBuffer = 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_1.hashString)(constants_1.ATLASPACK_VERSION + key + this.value.id);
+    }
+    addDependency(opts) {
+        // eslint-disable-next-line no-unused-vars
+        let { env, symbols, ...rest } = opts;
+        let dep = (0, Dependency_1.createDependency)(this.options.projectRoot, {
+            ...rest,
+            // @ts-expect-error TS2322
+            symbols,
+            env: (0, Environment_1.mergeEnvironments)(this.options.projectRoot, (0, EnvironmentManager_1.fromEnvironmentId)(this.value.env), env),
+            sourceAssetId: this.value.id,
+            sourcePath: (0, projectPath_1.fromProjectPath)(this.options.projectRoot, this.value.filePath),
+        });
+        let existing = this.value.dependencies.get(dep.id);
+        if (existing) {
+            (0, Dependency_1.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, utils_2.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_1.createAsset)(this.options.projectRoot, {
+                code: this.code,
+                filePath: this.value.filePath,
+                type: result.type,
+                bundleBehavior: result.bundleBehavior ??
+                    (this.value.bundleBehavior == null
+                        ? null
+                        : types_1.BundleBehaviorNames[this.value.bundleBehavior]),
+                isBundleSplittable: result.isBundleSplittable ?? this.value.isBundleSplittable,
+                isSource: this.value.isSource,
+                env: (0, Environment_1.mergeEnvironments)(this.options.projectRoot, (0, EnvironmentManager_1.fromEnvironmentId)(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,
+                },
+                // @ts-expect-error TS2322
+                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: source_map_1.default.safeToBuffer(result.map),
+            code: this.code,
+            invalidations: this.invalidations,
+        });
+        let dependencies = result.dependencies;
+        if (dependencies) {
+            for (let dep of dependencies) {
+                asset.addDependency(dep);
+            }
+        }
+        return asset;
+    }
+    updateId() {
+        // @ts-expect-error TS2345
+        this.value.id = (0, assetUtils_1.createAssetIdFromOptions)(this.value);
+    }
+}
+exports.default = UncommittedAsset;

package/dist/Validation.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const UncommittedAsset_1 = __importDefault(require("./UncommittedAsset"));
+const assetUtils_1 = require("./assetUtils");
+const Asset_1 = require("./public/Asset");
+const PluginOptions_1 = __importDefault(require("./public/PluginOptions"));
+const summarizeRequest_1 = __importDefault(require("./summarizeRequest"));
+const projectPath_1 = require("./projectPath");
+const profiler_1 = require("@atlaspack/profiler");
+class Validation {
+    constructor({ config, dedicatedThread, options, requests, report, workerApi, }) {
+        this.allAssets = {};
+        this.allValidators = {};
+        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_1.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_1.PluginLogger({ origin: validatorName });
+                let validatorTracer = new profiler_1.PluginTracer({
+                    origin: validatorName,
+                    category: 'validator',
+                });
+                let validatorResults = [];
+                try {
+                    // If the plugin supports the single-threading validateAll method, pass all assets to it.
+                    // @ts-expect-error TS2339
+                    if (plugin.validateAll && this.dedicatedThread) {
+                        // @ts-expect-error TS2339
+                        validatorResults = await plugin.validateAll({
+                            assets: assets.map((asset) => new Asset_1.Asset(asset)),
+                            options: pluginOptions,
+                            logger: validatorLogger,
+                            tracer: validatorTracer,
+                            resolveConfigWithPath: (configNames, assetFilePath) => (0, utils_1.resolveConfig)(this.options.inputFS, assetFilePath, configNames, this.options.projectRoot),
+                        });
+                    }
+                    // Otherwise, pass the assets one-at-a-time
+                    // @ts-expect-error TS2339
+                    else if (plugin.validate && !this.dedicatedThread) {
+                        await Promise.all(assets.map(async (input) => {
+                            let config = null;
+                            let publicAsset = new Asset_1.Asset(input);
+                            // @ts-expect-error TS2339
+                            if (plugin.getConfig) {
+                                // @ts-expect-error TS2339
+                                config = await plugin.getConfig({
+                                    asset: publicAsset,
+                                    options: pluginOptions,
+                                    logger: validatorLogger,
+                                    tracer: validatorTracer,
+                                    resolveConfig: (configNames) => (0, utils_1.resolveConfig)(this.options.inputFS, publicAsset.filePath, configNames, this.options.projectRoot),
+                                });
+                            }
+                            // @ts-expect-error TS2339
+                            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_1.default({
+                        diagnostic: (0, diagnostic_1.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',
+                // @ts-expect-error TS2322
+                filePath: (0, projectPath_1.fromProjectPath)(this.options.projectRoot, request.filePath),
+            });
+            let asset = await this.loadAsset(request);
+            let validators = await this.atlaspackConfig.getValidators(
+            // @ts-expect-error TS2345
+            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_1.default({
+                diagnostic: errors,
+            });
+        }
+        if (warnings.length > 0) {
+            logger_1.default.warn(warnings);
+        }
+    }
+    async loadAsset(request) {
+        let { filePath, env, code, sideEffects, query } = request;
+        let { content, size, isSource } = await (0, summarizeRequest_1.default)(this.options.inputFS, {
+            // @ts-expect-error TS2322
+            filePath: (0, projectPath_1.fromProjectPath)(this.options.projectRoot, request.filePath),
+        });
+        return new UncommittedAsset_1.default({
+            value: (0, assetUtils_1.createAsset)(this.options.projectRoot, {
+                code,
+                // @ts-expect-error TS2322
+                filePath: filePath,
+                isSource,
+                // @ts-expect-error TS2345
+                type: path_1.default.extname((0, projectPath_1.fromProjectPathRelative)(filePath)).slice(1),
+                query,
+                // @ts-expect-error TS2322
+                env: env,
+                stats: {
+                    time: 0,
+                    size,
+                },
+                sideEffects: sideEffects,
+            }),
+            options: this.options,
+            content,
+        });
+    }
+}
+exports.default = Validation;