@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/atlaspack-v3/worker/compat/plugin-config.js

@@ -0,0 +1,76 @@
+"use strict";
+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 _PluginConfig_projectRoot, _PluginConfig_inner;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginConfig = void 0;
+const Config_1 = __importDefault(require("../../../public/Config"));
+class PluginConfig {
+    constructor({ env, isSource, searchPath, projectRoot, fs, packageManager, }) {
+        // @ts-expect-error TS2564
+        _PluginConfig_projectRoot.set(this, void 0);
+        _PluginConfig_inner.set(this, void 0);
+        this.env = env;
+        this.isSource = isSource;
+        this.searchPath = searchPath;
+        __classPrivateFieldSet(this, _PluginConfig_inner, new Config_1.default(
+        // @ts-expect-error TS2345
+        {
+            invalidateOnConfigKeyChange: [],
+            invalidateOnFileCreate: [],
+            invalidateOnFileChange: new Set(),
+            devDeps: [],
+            searchPath: searchPath.replace(projectRoot + '/', ''),
+        }, {
+            projectRoot,
+            inputFS: fs,
+            outputFS: fs,
+            packageManager,
+        }), "f");
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileChange(filePath) { }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileCreate(invalidations) { }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnEnvChange(invalidation) { }
+    invalidateOnStartup() { }
+    invalidateOnBuild() { }
+    // eslint-disable-next-line no-unused-vars
+    addDevDependency(options) { }
+    // eslint-disable-next-line no-unused-vars
+    setCacheKey(key) { }
+    getConfig(
+    // eslint-disable-next-line no-unused-vars
+    filePaths, 
+    // eslint-disable-next-line no-unused-vars
+    options) {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getConfig(filePaths, options);
+    }
+    getConfigFrom(
+    // eslint-disable-next-line no-unused-vars
+    searchPath, 
+    // eslint-disable-next-line no-unused-vars
+    filePaths, 
+    // eslint-disable-next-line no-unused-vars
+    options) {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getConfigFrom(searchPath, filePaths, options);
+    }
+    getPackage() {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getPackage();
+    }
+}
+exports.PluginConfig = PluginConfig;
+_PluginConfig_projectRoot = new WeakMap(), _PluginConfig_inner = new WeakMap();

package/dist/atlaspack-v3/worker/compat/plugin-logger.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginLogger = void 0;
+class PluginLogger {
+    verbose(diagnostic) {
+        // eslint-disable-next-line no-console
+        console.log(diagnostic);
+    }
+    info(diagnostic) {
+        // eslint-disable-next-line no-console
+        console.info(diagnostic);
+    }
+    log(diagnostic) {
+        // eslint-disable-next-line no-console
+        console.log(diagnostic);
+    }
+    warn(diagnostic) {
+        // eslint-disable-next-line no-console
+        console.warn(diagnostic);
+    }
+    error(input) {
+        // eslint-disable-next-line no-console
+        console.error(input);
+    }
+}
+exports.PluginLogger = PluginLogger;

package/dist/atlaspack-v3/worker/compat/plugin-options.js

@@ -0,0 +1,122 @@
+"use strict";
+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 __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 _PluginOptions_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginOptions = void 0;
+class PluginOptions {
+    get env() {
+        if (!('env' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            return process.env;
+            // throw new Error('PluginOptions.env');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").env;
+    }
+    get projectRoot() {
+        if (!('projectRoot' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.projectRoot');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").projectRoot;
+    }
+    get packageManager() {
+        if (!('packageManager' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.packageManager');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").packageManager;
+    }
+    get mode() {
+        if (!('mode' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.mode');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").mode;
+    }
+    get parcelVersion() {
+        if (!('parcelVersion' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            return 'UNKNOWN VERSION';
+            // throw new Error('PluginOptions.parcelVersion');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").parcelVersion;
+    }
+    get hmrOptions() {
+        if (!('hmrOptions' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.hmrOptions');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").hmrOptions;
+    }
+    get serveOptions() {
+        if (!('serveOptions' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.serveOptions');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").serveOptions;
+    }
+    get shouldBuildLazily() {
+        if (!('shouldBuildLazily' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.shouldBuildLazily');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldBuildLazily;
+    }
+    get shouldAutoInstall() {
+        if (!('shouldAutoInstall' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.shouldAutoInstall');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldAutoInstall;
+    }
+    get logLevel() {
+        if (!('logLevel' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.logLevel');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").logLevel;
+    }
+    get cacheDir() {
+        if (!('cacheDir' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.cacheDir');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").cacheDir;
+    }
+    get inputFS() {
+        if (!('inputFS' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.inputFS');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").inputFS;
+    }
+    get outputFS() {
+        if (!('outputFS' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.outputFS');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").outputFS;
+    }
+    get instanceId() {
+        if (!('instanceId' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.instanceId');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").instanceId;
+    }
+    get detailedReport() {
+        if (!('detailedReport' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.detailedReport');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").detailedReport;
+    }
+    get featureFlags() {
+        if (!('featureFlags' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.featureFlags');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").featureFlags;
+    }
+    constructor(options) {
+        _PluginOptions_options.set(this, void 0);
+        // @ts-expect-error TS2322
+        __classPrivateFieldSet(this, _PluginOptions_options, options, "f");
+    }
+}
+exports.PluginOptions = PluginOptions;
+_PluginOptions_options = new WeakMap();

package/dist/atlaspack-v3/worker/compat/plugin-tracer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTracer = void 0;
+class PluginTracer {
+    // @ts-expect-error TS2416
+    createMeasurement() {
+        throw new Error('PluginTracer.createMeasurement');
+    }
+}
+exports.PluginTracer = PluginTracer;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Target = void 0;
+class Target {
+    constructor(inner, env) {
+        this.distDir = inner.distDir;
+        this.distEntry = inner.distEntry;
+        this.name = inner.name;
+        this.publicUrl = inner.publicUrl;
+        this.loc = inner.loc;
+        this.env = env;
+    }
+}
+exports.Target = Target;

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

@@ -0,0 +1,292 @@
+"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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlaspackWorker = void 0;
+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 module = __importStar(require("module"));
+const jsCallable_1 = require("../jsCallable");
+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);
+        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom }) => {
+            let customRequire = module.createRequire(resolveFrom);
+            let resolvedPath = customRequire.resolve(specifier);
+            let resolvedModule = await import(resolvedPath);
+            let instance = undefined;
+            if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+                instance = resolvedModule.default[CONFIG];
+            }
+            else if (resolvedModule.default &&
+                resolvedModule.default.default &&
+                resolvedModule.default.default[CONFIG]) {
+                instance = resolvedModule.default.default[CONFIG];
+            }
+            else {
+                throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
+            }
+            switch (kind) {
+                case 'resolver':
+                    __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").set(specifier, { resolver: instance });
+                    break;
+                case 'transformer':
+                    __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, { transformer: instance });
+                    break;
+            }
+        });
+        this.runResolverResolve = (0, jsCallable_1.jsCallable)(async ({ key, dependency: napiDependency, specifier, pipeline, pluginOptions, }) => {
+            const state = __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").get(key);
+            if (!state) {
+                throw new Error(`Resolver not found: ${key}`);
+            }
+            let packageManager = state.packageManager;
+            if (!packageManager) {
+                packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), pluginOptions.projectRoot);
+                state.packageManager = packageManager;
+            }
+            const env = new compat_1.Environment(napiDependency.env);
+            const dependency = new compat_1.Dependency(napiDependency, env);
+            const defaultOptions = {
+                logger: new compat_1.PluginLogger(),
+                tracer: new compat_1.PluginTracer(),
+                options: new compat_1.PluginOptions({
+                    ...pluginOptions,
+                    packageManager,
+                    shouldAutoInstall: false,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                }),
+            };
+            if (!('config' in state)) {
+                // @ts-expect-error TS2345
+                state.config = await state.resolver.loadConfig?.({
+                    config: new compat_1.PluginConfig({
+                        env,
+                        isSource: true,
+                        searchPath: specifier,
+                        projectRoot: pluginOptions.projectRoot,
+                        fs: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                        packageManager,
+                    }),
+                    ...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' },
+                };
+            }
+            return {
+                invalidations: [],
+                resolution: {
+                    type: 'resolved',
+                    filePath: result.filePath || '',
+                    canDefer: result.canDefer || false,
+                    sideEffects: result.sideEffects || false,
+                    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, env: napiEnv, options, asset: innerAsset }, contents, map) => {
+            const state = __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").get(key);
+            if (!state) {
+                throw new Error(`Transformer not found: ${key}`);
+            }
+            let packageManager = state.packageManager;
+            if (!packageManager) {
+                packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), options.projectRoot);
+                state.packageManager = packageManager;
+            }
+            const transformer = state.transformer;
+            const resolveFunc = (from, to) => {
+                let customRequire = module.createRequire(from);
+                let resolvedPath = customRequire.resolve(to);
+                return Promise.resolve(resolvedPath);
+            };
+            const env = new compat_1.Environment(napiEnv);
+            const mutableAsset = new compat_1.MutableAsset(innerAsset, 
+            // @ts-expect-error TS2345
+            contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, options.projectRoot);
+            const defaultOptions = {
+                logger: new compat_1.PluginLogger(),
+                tracer: new compat_1.PluginTracer(),
+                options: new compat_1.PluginOptions({
+                    ...options,
+                    packageManager,
+                    shouldAutoInstall: false,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                }),
+            };
+            // @ts-expect-error TS2345
+            const config = await transformer.loadConfig?.({
+                config: new compat_1.PluginConfig({
+                    env,
+                    isSource: true,
+                    searchPath: innerAsset.filePath,
+                    projectRoot: options.projectRoot,
+                    fs: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager,
+                }),
+                ...defaultOptions,
+            });
+            if (transformer.parse) {
+                const ast = await transformer.parse({
+                    // @ts-expect-error TS2322
+                    asset: mutableAsset,
+                    config,
+                    resolve: resolveFunc,
+                    ...defaultOptions,
+                });
+                if (ast) {
+                    mutableAsset.setAST(ast);
+                }
+            }
+            const result = await state.transformer.transform({
+                // @ts-expect-error TS2322
+                asset: mutableAsset,
+                config,
+                resolve: resolveFunc,
+                ...defaultOptions,
+            });
+            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);
+                    }
+                }
+            }
+            (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');
+            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;
+            }
+            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())
+                    : '',
+            ];
+        });
+        __classPrivateFieldSet(this, _AtlaspackWorker_resolvers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_transformers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_fs, new fs_1.NodeFS(), "f");
+    }
+}
+exports.AtlaspackWorker = AtlaspackWorker;
+_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap();
+// 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);

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;