Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
export function bundler(
entries: FilePath | Array,
opts?: InitialParcelOptions,
) {
return new Parcel({
entries,
disableCache: true,
logLevel: 'none',
defaultConfig,
inputFS,
outputFS,
workerFarm,
packageManager: new NodePackageManager(inputFS),
defaultEngines: {
browsers: ['last 1 Chrome version'],
node: '8',
},
// $FlowFixMe
...opts,
});
}
import invariant from 'assert';
import Parcel, {createWorkerFarm} from '@parcel/core';
import defaultConfigContents from '@parcel/config-default';
import assert from 'assert';
import vm from 'vm';
import {NodeFS, MemoryFS, OverlayFS, ncp as _ncp} from '@parcel/fs';
import path from 'path';
import WebSocket from 'ws';
import nullthrows from 'nullthrows';
import {makeDeferredWithPromise} from '@parcel/utils';
import _chalk from 'chalk';
import resolve from 'resolve';
import {NodePackageManager} from '@parcel/package-manager';
const workerFarm = createWorkerFarm();
export const inputFS = new NodeFS();
export let outputFS = new MemoryFS(workerFarm);
export let overlayFS = new OverlayFS(outputFS, inputFS);
beforeEach(() => {
outputFS = new MemoryFS(workerFarm);
overlayFS = new OverlayFS(outputFS, inputFS);
});
// Recursively copies a directory from the inputFS to the outputFS
export async function ncp(source: FilePath, destination: FilePath) {
await _ncp(inputFS, source, outputFS, destination);
}
// Mocha is currently run with exit: true because of this issue preventing us
// from properly ending the workerfarm after the test run:
export default function register(opts = DEFAULT_CLI_OPTS) {
// Replace old hook, as this one likely contains options.
if (hooks) {
for (let extension in hooks) {
hooks[extension]();
}
}
let parcel = new Parcel({
entries: [path.join(process.cwd(), 'index.js')],
cliOpts: opts
});
let environment = new Environment({
context: 'node',
engines: {
node: process.versions.node
}
});
syncPromise(parcel.init());
let isProcessing = false;
// As Parcel is pretty much fully asynchronous, create an async function and wrap it in a syncPromise later...
function register(inputOpts?: InitialParcelOptions): IDisposable {
let opts: InitialParcelOptions = {
...defaultConfig,
...(inputOpts || {}),
};
// Replace old hook, as this one likely contains options.
if (lastDisposable) {
lastDisposable.dispose();
}
let parcel = new Parcel({
logLevel: 'error',
...opts,
});
let env = {
context: 'node',
engines: {
node: process.versions.node,
},
};
syncPromise(parcel.init());
let isProcessing = false;
// As Parcel is pretty much fully asynchronous, create an async function and wrap it in a syncPromise later...
export default function register(opts = DEFAULT_CLI_OPTS) {
// Replace old hook, as this one likely contains options.
if (hooks) {
for (let extension in hooks) {
hooks[extension]();
}
}
let parcel = new Parcel({
entries: [path.join(process.cwd(), 'index.js')],
cliOpts: opts
});
let environment = new Environment({
context: 'node',
engines: {
node: process.versions.node
}
});
syncPromise(parcel.init());
let isProcessing = false;
// As Parcel is pretty much fully asynchronous, create an async function and wrap it in a syncPromise later...
async function fileProcessor(code, filename) {
if (isProcessing) {
return code;
}
async function run(entries: Array, command: any) {
entries = entries.map(entry => path.resolve(entry));
if (entries.length === 0) {
console.log('No entries found');
return;
}
let Parcel = require('@parcel/core').default;
let packageManager = new NodePackageManager(new NodeFS());
let defaultConfig: ParcelConfigFile = await packageManager.require(
'@parcel/config-default',
__filename
);
let parcel = new Parcel({
entries,
packageManager,
defaultConfig: {
...defaultConfig,
filePath: (await packageManager.resolve(
'@parcel/config-default',
__filename
)).resolved
},
patchConsole: true,
...(await normalizeOptions(command))
});
if (command.name() === 'watch' || command.name() === 'serve') {
let {unsubscribe} = await parcel.watch(err => {
if (err) {
function resolveFile(currFile, targetFile) {
try {
isProcessing = true;
let dep = new Dependency({
moduleSpecifier: targetFile,
sourcePath: currFile,
env: environment
});
targetFile = syncPromise(parcel.resolverRunner.resolve(dep));
let targetFileExtension = path.extname(targetFile);
if (!hooks[targetFileExtension]) {
hooks[targetFileExtension] = addHook(hookFunction, {
exts: [targetFileExtension],
ignoreNodeModules: false
});
}
return targetFile;