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

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

@@ -0,0 +1,398 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs, _AtlaspackWorker_packageManager, _AtlaspackWorker_options, _AtlaspackWorker_sideEffectDetector;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlaspackWorker = void 0;
+/* eslint-disable import/first */
+const side_effect_detector_1 = require("./side-effect-detector");
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new side_effect_detector_1.SideEffectDetector();
+sideEffectDetector.install();
+const assert_1 = __importDefault(require("assert"));
+const napi = __importStar(require("@atlaspack/rust"));
+const fs_1 = require("@atlaspack/fs");
+const package_manager_1 = require("@atlaspack/package-manager");
+const worker_threads_1 = require("worker_threads");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const module = __importStar(require("module"));
+const jsCallable_1 = require("../jsCallable");
+const logger_2 = require("@atlaspack/logger");
+const compat_1 = require("./compat");
+const CONFIG = Symbol.for('parcel-plugin-config');
+class AtlaspackWorker {
+    constructor() {
+        _AtlaspackWorker_resolvers.set(this, void 0);
+        _AtlaspackWorker_transformers.set(this, void 0);
+        _AtlaspackWorker_fs.set(this, void 0);
+        _AtlaspackWorker_packageManager.set(this, void 0);
+        _AtlaspackWorker_options.set(this, void 0);
+        _AtlaspackWorker_sideEffectDetector.set(this, void 0);
+        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom, options }) => {
+            // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
+            let resolvedModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").require(specifier, resolveFrom, { shouldAutoInstall: false });
+            let instance = undefined;
+            // Check for CommonJS export (module.exports = new Plugin(...))
+            if (resolvedModule[CONFIG]) {
+                instance = resolvedModule[CONFIG];
+            }
+            else if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+                // ESM default export
+                instance = resolvedModule.default[CONFIG];
+            }
+            else if (resolvedModule.default &&
+                resolvedModule.default.default &&
+                resolvedModule.default.default[CONFIG]) {
+                // Double-wrapped default export
+                instance = resolvedModule.default.default[CONFIG];
+            }
+            else {
+                throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
+            }
+            if (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+                __classPrivateFieldSet(this, _AtlaspackWorker_options, {
+                    ...options,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager: __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f"),
+                    shouldAutoInstall: false,
+                }, "f");
+            }
+            // Set feature flags in the worker process
+            let featureFlagsModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").require('@atlaspack/feature-flags', __filename, { shouldAutoInstall: false });
+            featureFlagsModule.setFeatureFlags(options.featureFlags);
+            switch (kind) {
+                case 'resolver':
+                    __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").set(specifier, { resolver: instance });
+                    break;
+                case 'transformer': {
+                    return this.initializeTransformer(instance, specifier);
+                }
+            }
+        });
+        this.runResolverResolve = (0, jsCallable_1.jsCallable)(async ({ key, dependency: napiDependency, specifier, pipeline }) => {
+            const state = __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").get(key);
+            if (!state) {
+                throw new Error(`Resolver not found: ${key}`);
+            }
+            const env = new compat_1.Environment(napiDependency.env);
+            const dependency = new compat_1.Dependency(napiDependency, env);
+            const defaultOptions = {
+                logger: new logger_2.PluginLogger({ origin: key }),
+                tracer: new compat_1.PluginTracer(),
+                options: new compat_1.PluginOptions(this.options),
+            };
+            if (!('config' in state)) {
+                // @ts-expect-error TS2345
+                state.config = await state.resolver.loadConfig?.({
+                    config: new compat_1.PluginConfig({
+                        env: napiDependency.env,
+                        plugin: key,
+                        isSource: true,
+                        searchPath: 'index',
+                    }, this.options),
+                    ...defaultOptions,
+                });
+            }
+            // @ts-expect-error TS2345
+            const result = await state.resolver.resolve({
+                specifier,
+                dependency,
+                pipeline,
+                config: state.config,
+                ...defaultOptions,
+            });
+            if (!result) {
+                return {
+                    invalidations: [],
+                    resolution: { type: 'unresolved' },
+                };
+            }
+            if (result.isExcluded) {
+                return {
+                    invalidations: [],
+                    resolution: { type: 'excluded' },
+                };
+            }
+            // A resolver may return a result without filePath to indicate it didn't
+            // resolve the dependency (equivalent to returning null). The JS-side
+            // PathRequest treats this as "try the next resolver".
+            if (!result.filePath) {
+                return {
+                    invalidations: [],
+                    resolution: { type: 'unresolved' },
+                };
+            }
+            return {
+                invalidations: [],
+                resolution: {
+                    type: 'resolved',
+                    filePath: result.filePath,
+                    canDefer: result.canDefer || false,
+                    sideEffects: result.sideEffects ?? true,
+                    code: result.code ?? undefined,
+                    meta: result.meta || undefined,
+                    pipeline: result.pipeline || undefined,
+                    priority: compat_1.dependencyPriorityMap.intoNullable(result.priority),
+                    query: result.query && result.query.toString(),
+                },
+            };
+        });
+        this.runTransformerTransform = (0, jsCallable_1.jsCallable)(async ({ key, asset: innerAsset }, contents, map) => {
+            const instance = __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").get(key);
+            if (!instance) {
+                throw new Error(`Transformer not found: ${key}`);
+            }
+            let { transformer, config, allowedEnv = new Set() } = instance;
+            let cacheBailouts = [];
+            const resolveFunc = (from, to) => {
+                let customRequire = module.createRequire(from);
+                let resolvedPath = customRequire.resolve(to);
+                // Tranformer not cacheable due to use of the resolve function
+                cacheBailouts.push(`resolve(${from}, ${to})`);
+                return Promise.resolve(resolvedPath);
+            };
+            const env = new compat_1.Environment(innerAsset.env);
+            let mutableAsset = new compat_1.MutableAsset(innerAsset, 
+            // @ts-expect-error TS2345
+            contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, this.options.projectRoot);
+            const pluginOptions = new compat_1.PluginOptions(this.options);
+            const defaultOptions = {
+                logger: new logger_2.PluginLogger({ origin: key }),
+                tracer: new compat_1.PluginTracer(),
+                options: pluginOptions,
+            };
+            if (transformer.loadConfig) {
+                if (config != null) {
+                    throw new Error(`Transformer (${key}) should not implement 'setup' and 'loadConfig'`);
+                }
+                // @ts-expect-error TS2345
+                config = await transformer.loadConfig({
+                    config: new compat_1.PluginConfig({
+                        plugin: key,
+                        isSource: innerAsset.isSource,
+                        searchPath: innerAsset.filePath,
+                        env,
+                    }, this.options),
+                    ...defaultOptions,
+                });
+                // Transformer uses the deprecated loadConfig API, so mark as not
+                // cachable
+                cacheBailouts.push(`Transformer.loadConfig`);
+            }
+            if (transformer.parse) {
+                const ast = await transformer.parse({
+                    // @ts-expect-error TS2322
+                    asset: mutableAsset,
+                    config,
+                    resolve: resolveFunc,
+                    ...defaultOptions,
+                });
+                if (ast) {
+                    mutableAsset.setAST(ast);
+                }
+                cacheBailouts.push(`Transformer.parse`);
+            }
+            const [result, sideEffects] = await __classPrivateFieldGet(this, _AtlaspackWorker_sideEffectDetector, "f").monitorSideEffects(key, () => transformer.transform({
+                // @ts-expect-error TS2322
+                asset: mutableAsset,
+                config,
+                resolve: resolveFunc,
+                ...defaultOptions,
+            }));
+            if (sideEffects.envUsage.didEnumerate) {
+                cacheBailouts.push(`Env access: enumeration of process.env`);
+            }
+            for (let variable of sideEffects.envUsage.vars) {
+                if (variable in allowedEnv) {
+                    continue;
+                }
+                cacheBailouts.push(`Env access: ${variable}`);
+            }
+            for (let { method, path } of sideEffects.fsUsage) {
+                cacheBailouts.push(`FS usage: ${method}(${path})`);
+            }
+            (0, assert_1.default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+            (0, assert_1.default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
+            if (transformer.generate) {
+                const ast = await mutableAsset.getAST();
+                if (ast) {
+                    const output = await transformer.generate({
+                        // @ts-expect-error TS2322
+                        asset: mutableAsset,
+                        ast,
+                        ...defaultOptions,
+                    });
+                    if (typeof output.content === 'string') {
+                        mutableAsset.setCode(output.content);
+                    }
+                    else if (output.content instanceof Buffer) {
+                        mutableAsset.setBuffer(output.content);
+                    }
+                    else {
+                        // @ts-expect-error TS2345
+                        mutableAsset.setStream(output.content);
+                    }
+                    if (output.map) {
+                        mutableAsset.setMap(output.map);
+                    }
+                }
+            }
+            let assetBuffer = await mutableAsset.getBuffer();
+            // If the asset has no code, we set the buffer to null, which we can
+            // detect in Rust, to avoid passing back an empty buffer, which we can't.
+            if (assetBuffer.length === 0) {
+                assetBuffer = null;
+            }
+            if (pluginOptions.used) {
+                // Plugin options accessed, so not cachable
+                cacheBailouts.push(`Plugin options accessed`);
+            }
+            return [
+                {
+                    id: mutableAsset.id,
+                    bundleBehavior: compat_1.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
+                    code: [],
+                    filePath: mutableAsset.filePath,
+                    isBundleSplittable: mutableAsset.isBundleSplittable,
+                    isSource: mutableAsset.isSource,
+                    meta: mutableAsset.meta,
+                    pipeline: mutableAsset.pipeline,
+                    // Query should be undefined if it's empty
+                    query: mutableAsset.query.toString() || undefined,
+                    sideEffects: mutableAsset.sideEffects,
+                    symbols: mutableAsset.symbols.intoNapi(),
+                    type: mutableAsset.type,
+                    uniqueKey: mutableAsset.uniqueKey,
+                },
+                assetBuffer,
+                // Only send back the map if it has changed
+                mutableAsset.isMapDirty
+                    ? // @ts-expect-error TS2533
+                        JSON.stringify((await mutableAsset.getMap()).toVLQ())
+                    : '',
+                // Limit to first 10 bailouts
+                cacheBailouts.slice(0, 10),
+            ];
+        });
+        __classPrivateFieldSet(this, _AtlaspackWorker_resolvers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_transformers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_fs, new fs_1.NodeFS(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_packageManager, new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), '/'), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_sideEffectDetector, sideEffectDetector, "f"); // Use the global detector that was installed before imports
+    }
+    clearState() {
+        __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").clear();
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").clear();
+        __classPrivateFieldSet(this, _AtlaspackWorker_options, undefined, "f");
+    }
+    get options() {
+        if (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+            throw new Error('Plugin options have not been initialized');
+        }
+        return __classPrivateFieldGet(this, _AtlaspackWorker_options, "f");
+    }
+    async initializeTransformer(instance, specifier) {
+        let transformer = instance;
+        let setup, config, allowedEnv;
+        let packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), this.options.projectRoot);
+        if (transformer.setup) {
+            let setupResult = await transformer.setup({
+                logger: new logger_2.PluginLogger({ origin: specifier }),
+                options: new compat_1.PluginOptions({
+                    ...this.options,
+                    shouldAutoInstall: false,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager,
+                }),
+                config: new compat_1.PluginConfig({
+                    plugin: specifier,
+                    searchPath: 'index',
+                    // Consider project setup config as source
+                    isSource: true,
+                }, this.options),
+            });
+            config = setupResult?.config;
+            allowedEnv = Object.fromEntries(setupResult?.env?.map((env) => [env, process.env[env]]) || []);
+            // Always add the following env vars to the cache key
+            allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
+            setup = {
+                conditions: setupResult?.conditions,
+                config,
+                env: allowedEnv,
+                disableCache: setupResult?.disableCache,
+            };
+        }
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, {
+            transformer,
+            config,
+            packageManager,
+            allowedEnv,
+        });
+        return setup;
+    }
+}
+exports.AtlaspackWorker = AtlaspackWorker;
+_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap(), _AtlaspackWorker_options = new WeakMap(), _AtlaspackWorker_sideEffectDetector = new WeakMap();
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
+logger_1.default.onLog((event) => {
+    worker_threads_1.parentPort?.postMessage({ type: 'logEvent', event });
+});
+// Create napi worker and send it back to main thread
+const worker = new AtlaspackWorker();
+const napiWorker = napi.newNodejsWorker(worker);
+worker_threads_1.parentPort?.postMessage(napiWorker);
+worker_threads_1.parentPort?.setMaxListeners(worker_threads_1.parentPort.getMaxListeners() + 1);
+worker_threads_1.parentPort?.addListener('message', (message) => {
+    if (message === 'clearState') {
+        worker.clearState();
+        worker_threads_1.parentPort?.postMessage('stateCleared');
+    }
+});

package/dist/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR = exports.STARTUP = exports.OPTION_CHANGE = exports.ENV_CHANGE = exports.FILE_DELETE = exports.FILE_UPDATE = exports.FILE_CREATE = exports.INITIAL_BUILD = exports.VALID = exports.HASH_REF_REGEX = exports.HASH_REF_HASH_LEN = exports.HASH_REF_PREFIX = exports.ATLASPACK_VERSION = void 0;
+const package_json_1 = require("../package.json");
+exports.ATLASPACK_VERSION = package_json_1.version;
+exports.HASH_REF_PREFIX = 'HASH_REF_';
+exports.HASH_REF_HASH_LEN = 16;
+exports.HASH_REF_REGEX = new RegExp(`${exports.HASH_REF_PREFIX}\\w{${exports.HASH_REF_HASH_LEN}}`, 'g');
+exports.VALID = 0;
+exports.INITIAL_BUILD = 1 << 0;
+exports.FILE_CREATE = 1 << 1;
+exports.FILE_UPDATE = 1 << 2;
+exports.FILE_DELETE = 1 << 3;
+exports.ENV_CHANGE = 1 << 4;
+exports.OPTION_CHANGE = 1 << 5;
+exports.STARTUP = 1 << 6;
+exports.ERROR = 1 << 7;