@parcel/utils 2.0.0-nightly.150 → 2.0.0-nightly.1501

package/lib/resolve.js

@@ -1,93 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolve = resolve;
-exports.resolveSync = resolveSync;
-
-var _promisify = _interopRequireDefault(require("./promisify"));
-
-var _resolve2 = _interopRequireDefault(require("resolve"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-const resolveAsync = (0, _promisify.default)(_resolve2.default);
-
-async function resolve(fs, id, opts) {
-  let res = await resolveAsync(id, _objectSpread({}, opts, {
-    async readFile(filename, callback) {
-      try {
-        let res = await fs.readFile(filename);
-        callback(null, res);
-      } catch (err) {
-        callback(err);
-      }
-    },
-
-    async isFile(file, callback) {
-      try {
-        let stat = await fs.stat(file);
-        callback(null, stat.isFile());
-      } catch (err) {
-        callback(null, false);
-      }
-    },
-
-    async isDirectory(file, callback) {
-      try {
-        let stat = await fs.stat(file);
-        callback(null, stat.isDirectory());
-      } catch (err) {
-        callback(null, false);
-      }
-    }
-
-  }));
-
-  if (typeof res === 'string') {
-    return {
-      resolved: res
-    };
-  }
-
-  return {
-    resolved: res[0],
-    pkg: res[1]
-  };
-}
-
-function resolveSync(fs, id, opts) {
-  // $FlowFixMe
-  let res = _resolve2.default.sync(id, _objectSpread({}, opts, {
-    readFileSync: (...args) => {
-      return fs.readFileSync(...args);
-    },
-    isFile: file => {
-      try {
-        let stat = fs.statSync(file);
-        return stat.isFile();
-      } catch (err) {
-        return false;
-      }
-    },
-    isDirectory: file => {
-      try {
-        let stat = fs.statSync(file);
-        return stat.isDirectory();
-      } catch (err) {
-        return false;
-      }
-    }
-  }));
-
-  return {
-    resolved: res
-  };
-}

package/lib/schema.js

@@ -1,320 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _diagnostic = _interopRequireWildcard(require("@parcel/diagnostic"));
-
-var _jsLevenshtein = _interopRequireDefault(require("js-levenshtein"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-// $FlowFixMe untyped
-function validateSchema(schema, data) {
-  function walk(schemaAncestors, dataNode, dataPath) {
-    let [schemaNode] = schemaAncestors;
-
-    if (schemaNode.type) {
-      let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
-
-      if (schemaNode.type !== type) {
-        return {
-          type: 'type',
-          dataType: 'value',
-          dataPath,
-          expectedTypes: [schemaNode.type],
-          ancestors: schemaAncestors,
-          prettyType: schemaNode.__type
-        };
-      } else {
-        switch (schemaNode.type) {
-          case 'array':
-            {
-              if (schemaNode.items) {
-                let results = []; // $FlowFixMe type was already checked
-
-                for (let i = 0; i < dataNode.length; i++) {
-                  let result = walk([schemaNode.items].concat(schemaAncestors), // $FlowFixMe type was already checked
-                  dataNode[i], dataPath + '/' + i);
-                  if (result) results.push(result);
-                }
-
-                if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
-              }
-
-              break;
-            }
-
-          case 'string':
-            {
-              // $FlowFixMe type was already checked
-              let value = dataNode;
-
-              if (schemaNode.enum) {
-                if (!schemaNode.enum.includes(value)) {
-                  return {
-                    type: 'enum',
-                    dataType: 'value',
-                    dataPath,
-                    expectedValues: schemaNode.enum,
-                    actualValue: value,
-                    ancestors: schemaAncestors
-                  };
-                }
-              } else if (schemaNode.__validate) {
-                let validationError = schemaNode.__validate(value); // $FlowFixMe
-
-
-                if (validationError) {
-                  return {
-                    type: 'other',
-                    dataType: 'value',
-                    dataPath,
-                    message: validationError,
-                    actualValue: value,
-                    ancestors: schemaAncestors
-                  };
-                }
-              }
-
-              break;
-            }
-
-          case 'object':
-            {
-              let results = [];
-              let invalidProps;
-
-              if (schemaNode.__forbiddenProperties) {
-                // $FlowFixMe type was already checked
-                let keys = Object.keys(dataNode);
-                invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
-                results.push(...invalidProps.map(k => ({
-                  type: 'forbidden-prop',
-                  dataPath: dataPath + '/' + k,
-                  dataType: 'key',
-                  prop: k,
-                  expectedProps: Object.keys(schemaNode.properties),
-                  actualProps: keys,
-                  ancestors: schemaAncestors
-                })));
-              }
-
-              if (schemaNode.required) {
-                // $FlowFixMe type was already checked
-                let keys = Object.keys(dataNode);
-                let missingKeys = schemaNode.required.filter(val => !keys.includes(val));
-                results.push(...missingKeys.map(k => ({
-                  type: 'missing-prop',
-                  dataPath,
-                  dataType: null,
-                  prop: k,
-                  expectedProps: schemaNode.required,
-                  actualProps: keys,
-                  ancestors: schemaAncestors
-                })));
-              }
-
-              if (schemaNode.properties) {
-                let {
-                  additionalProperties = true
-                } = schemaNode; // $FlowFixMe type was already checked
-
-                for (let k in dataNode) {
-                  if (invalidProps && invalidProps.includes(k)) {
-                    // Don't check type on forbidden props
-                    continue;
-                  } else if (k in schemaNode.properties) {
-                    let result = walk([schemaNode.properties[k]].concat(schemaAncestors), // $FlowFixMe type was already checked
-                    dataNode[k], dataPath + '/' + k);
-                    if (result) results.push(result);
-                  } else {
-                    if (typeof additionalProperties === 'boolean') {
-                      if (!additionalProperties) {
-                        results.push({
-                          type: 'enum',
-                          dataType: 'key',
-                          dataPath: dataPath + '/' + k,
-                          expectedValues: Object.keys(schemaNode.properties).filter( // $FlowFixMe type was already checked
-                          p => !(p in dataNode)),
-                          actualValue: k,
-                          ancestors: schemaAncestors,
-                          prettyType: schemaNode.__type
-                        });
-                      }
-                    } else {
-                      let result = walk([additionalProperties].concat(schemaAncestors), // $FlowFixMe type was already checked
-                      dataNode[k], dataPath + '/' + k);
-                      if (result) results.push(result);
-                    }
-                  }
-                }
-              }
-
-              if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
-              break;
-            }
-
-          case 'boolean':
-            // NOOP, type was checked already
-            break;
-
-          default:
-            throw new Error(`Unimplemented schema type ${type}?`);
-        }
-      }
-    } else {
-      if (schemaNode.enum && !schemaNode.enum.includes(dataNode)) {
-        return {
-          type: 'enum',
-          dataType: 'value',
-          dataPath: dataPath,
-          expectedValues: schemaNode.enum,
-          actualValue: schemaNode,
-          ancestors: schemaAncestors
-        };
-      }
-
-      if (schemaNode.oneOf || schemaNode.allOf) {
-        let list = schemaNode.oneOf || schemaNode.allOf;
-        let results = [];
-
-        for (let f of list) {
-          let result = walk([f].concat(schemaAncestors), dataNode, dataPath);
-          if (result) results.push(result);
-        }
-
-        if (schemaNode.oneOf ? results.length == schemaNode.oneOf.length : results.length > 0) {
-          // return the result with more values / longer key
-          results.sort((a, b) => Array.isArray(a) || Array.isArray(b) ? Array.isArray(a) && !Array.isArray(b) ? -1 : !Array.isArray(a) && Array.isArray(b) ? 1 : Array.isArray(a) && Array.isArray(b) ? b.length - a.length : 0 : b.dataPath.length - a.dataPath.length);
-          return results[0];
-        }
-      } else if (schemaNode.not) {
-        let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
-
-        if (!result || result.length == 0) {
-          return {
-            type: 'other',
-            dataPath,
-            dataType: null,
-            message: schemaNode.__message,
-            actualValue: dataNode,
-            ancestors: schemaAncestors
-          };
-        }
-      }
-    }
-
-    return undefined;
-  }
-
-  let result = walk([schema], data, '');
-  return Array.isArray(result) ? result : result ? [result] : [];
-}
-
-var _default = validateSchema;
-exports.default = _default;
-
-function fuzzySearch(expectedValues, actualValue) {
-  let result = expectedValues.map(exp => [exp, (0, _jsLevenshtein.default)(exp, actualValue)]).filter( // Remove if more than half of the string would need to be changed
-  ([, d]) => d * 2 < actualValue.length);
-  result.sort(([, a], [, b]) => a - b);
-  return result.map(([v]) => v);
-}
-
-validateSchema.diagnostic = function (schema, data, dataContentsPath, dataContents, origin, prependKey, message) {
-  let errors = validateSchema(schema, data);
-
-  if (errors.length) {
-    let dataContentsString = typeof dataContents === 'string' ? dataContents : // $FlowFixMe
-    JSON.stringify(dataContents, null, '\t');
-    let keys = errors.map(e => {
-      let message;
-
-      if (e.type === 'enum') {
-        let {
-          actualValue
-        } = e;
-        let expectedValues = e.expectedValues.map(String);
-        let likely = actualValue != null ? fuzzySearch(expectedValues, String(actualValue)) : [];
-
-        if (likely.length > 0) {
-          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
-        } else if (expectedValues.length > 0) {
-          message = `Possible values: ${expectedValues.map(v => JSON.stringify(v)).join(', ')}`;
-        } else {
-          message = 'Unexpected value';
-        }
-      } else if (e.type === 'forbidden-prop') {
-        let {
-          prop,
-          expectedProps,
-          actualProps
-        } = e;
-        let likely = fuzzySearch(expectedProps, prop).filter(v => !actualProps.includes(v));
-
-        if (likely.length > 0) {
-          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
-        } else {
-          message = 'Unexpected property';
-        }
-      } else if (e.type === 'missing-prop') {
-        let {
-          prop,
-          actualProps
-        } = e;
-        let likely = fuzzySearch(actualProps, prop);
-
-        if (likely.length > 0) {
-          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
-          e.dataPath += '/' + prop;
-          e.dataType = 'key';
-        } else {
-          message = `Missing property ${prop}`;
-        }
-      } else if (e.type === 'type') {
-        if (e.prettyType != null) {
-          message = `Expected ${e.prettyType}`;
-        } else {
-          message = `Expected type ${e.expectedTypes.join(', ')}`;
-        }
-      } else {
-        message = e.message;
-      }
-
-      return {
-        key: e.dataPath,
-        type: e.dataType,
-        message
-      };
-    });
-    let codeFrame = {
-      code: dataContentsString,
-      codeHighlights: (0, _diagnostic.generateJSONCodeHighlights)(dataContentsString, keys.map(({
-        key,
-        type,
-        message
-      }) => ({
-        key: prependKey + key,
-        type: type,
-        message
-      })))
-    };
-    throw new _diagnostic.default({
-      diagnostic: {
-        message,
-        origin,
-        // $FlowFixMe should be a sketchy string check
-        filePath: dataContentsPath || undefined,
-        language: 'json',
-        codeFrame
-      }
-    });
-  }
-};

package/lib/serializeObject.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = serializeObject;
-
-var _terser = require("terser");
-
-var _serializeToJs = _interopRequireDefault(require("serialize-to-js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function serializeObject(obj, shouldMinify = false) {
-  let code = `module.exports = ${(0, _serializeToJs.default)(obj)};`;
-
-  if (shouldMinify) {
-    let minified = (0, _terser.minify)(code);
-
-    if (minified.error) {
-      throw minified.error;
-    }
-
-    code = minified.code;
-  }
-
-  return code;
-}

package/lib/stream.js

@@ -1,51 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.measureStreamLength = measureStreamLength;
-exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
-exports.bufferStream = bufferStream;
-exports.blobToStream = blobToStream;
-
-var _stream = require("stream");
-
-function measureStreamLength(stream) {
-  return new Promise((resolve, reject) => {
-    let length = 0;
-    stream.on('data', chunk => {
-      length += chunk;
-    });
-    stream.on('end', () => resolve(length));
-    stream.on('error', reject);
-  });
-}
-
-function readableFromStringOrBuffer(str) {
-  // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
-  const stream = new _stream.Readable();
-  stream.push(str);
-  stream.push(null);
-  return stream;
-}
-
-function bufferStream(stream) {
-  return new Promise((resolve, reject) => {
-    let buf = Buffer.from([]);
-    stream.on('data', data => {
-      buf = Buffer.concat([buf, data]);
-    });
-    stream.on('end', () => {
-      resolve(buf);
-    });
-    stream.on('error', reject);
-  });
-}
-
-function blobToStream(blob) {
-  if (blob instanceof _stream.Readable) {
-    return blob;
-  }
-
-  return readableFromStringOrBuffer(blob);
-}

package/lib/throttle.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = throttle;
-
-function throttle(fn, delay) {
-  let lastCalled;
-  return function (...args) {
-    if (lastCalled == null || lastCalled + delay <= Date.now()) {
-      fn.call(this, ...args);
-      lastCalled = Date.now();
-    }
-  };
-}

package/lib/urlJoin.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = urlJoin;
-
-var _url = _interopRequireDefault(require("url"));
-
-var _path = _interopRequireDefault(require("path"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Joins a path onto a URL, and normalizes Windows paths
- * e.g. from \path\to\res.js to /path/to/res.js.
- */
-function urlJoin(publicURL, assetPath) {
-  const url = _url.default.parse(publicURL, false, true);
-
-  const assetUrl = _url.default.parse(assetPath);
-
-  url.pathname = _path.default.posix.join(url.pathname, assetUrl.pathname);
-  url.search = assetUrl.search;
-  url.hash = assetUrl.hash;
-  return _url.default.format(url);
-}

package/src/.babelrc

@@ -1,3 +0,0 @@
-{
-  "presets": ["@parcel/babel-preset"]
-}

package/src/escape-markdown.js

@@ -1,10 +0,0 @@
-// @flow
-const escapeCharacters = ['\\', '*', '_', '~'];
-
-export function escapeMarkdown(s: string): string {
-  for (const char of escapeCharacters) {
-    s = s.replace(new RegExp(`\\${char}`, 'g'), `\\${char}`);
-  }
-
-  return s;
-}

package/src/generateBundleReport.js

@@ -1,51 +0,0 @@
-// @flow strict-local
-
-import type {Asset, BundleGraph} from '@parcel/types';
-import nullthrows from 'nullthrows';
-
-export type BundleReport = {|
-  bundles: Array<{|
-    filePath: string,
-    size: number,
-    time: number,
-    largestAssets: Array<{|
-      filePath: string,
-      size: number,
-      time: number,
-    |}>,
-    totalAssets: number,
-  |}>,
-|};
-
-export default function generateBundleReport(
-  bundleGraph: BundleGraph,
-  largestAssetCount: number = 10,
-): BundleReport {
-  let bundles = [];
-  bundleGraph.traverseBundles(bundle => {
-    bundles.push(bundle);
-  });
-  bundles.sort((a, b) => b.stats.size - a.stats.size);
-
-  return {
-    bundles: bundles.map(bundle => {
-      let assets: Array<Asset> = [];
-      bundle.traverseAssets(asset => {
-        assets.push(asset);
-      });
-      assets.sort((a, b) => b.stats.size - a.stats.size);
-
-      return {
-        filePath: nullthrows(bundle.filePath),
-        size: bundle.stats.size,
-        time: bundle.stats.time,
-        largestAssets: assets.slice(0, largestAssetCount).map(asset => ({
-          filePath: asset.filePath,
-          size: asset.stats.size,
-          time: asset.stats.time,
-        })),
-        totalAssets: assets.length,
-      };
-    }),
-  };
-}

package/src/loadSourceMapUrl.js

@@ -1,33 +0,0 @@
-// @flow
-import type {FileSystem} from '@parcel/fs';
-import path from 'path';
-
-const SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
-const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
-
-export function matchSourceMappingURL(contents: string) {
-  return contents.match(SOURCEMAP_RE);
-}
-
-export default async function loadSourceMapUrl(
-  fs: FileSystem,
-  filename: string,
-  contents: string,
-) {
-  let match = matchSourceMappingURL(contents);
-  if (match) {
-    let url = match[1].trim();
-    let dataURLMatch = url.match(DATA_URL_RE);
-    filename = dataURLMatch ? filename : path.join(path.dirname(filename), url);
-
-    return {
-      url,
-      filename,
-      map: JSON.parse(
-        dataURLMatch
-          ? Buffer.from(dataURLMatch[1], 'base64').toString()
-          : await fs.readFile(filename, 'utf8'),
-      ),
-    };
-  }
-}

package/src/md5.js

@@ -1,44 +0,0 @@
-// @flow strict-local
-
-import type {Readable} from 'stream';
-import type {FileSystem} from '@parcel/fs';
-
-import crypto from 'crypto';
-import {objectSortedEntriesDeep} from './collection';
-
-type StringHashEncoding = 'hex' | 'latin1' | 'binary' | 'base64';
-
-export function md5FromString(
-  string: string | Buffer,
-  encoding: StringHashEncoding = 'hex',
-): string {
-  return crypto
-    .createHash('md5')
-    .update(string)
-    .digest(encoding);
-}
-
-export function md5FromReadableStream(stream: Readable): Promise<string> {
-  return new Promise((resolve, reject) => {
-    stream
-      .pipe(crypto.createHash('md5').setEncoding('hex'))
-      .on('finish', function() {
-        resolve(this.read());
-      })
-      .on('error', reject);
-  });
-}
-
-export function md5FromObject(
-  obj: {+[string]: mixed, ...},
-  encoding: StringHashEncoding = 'hex',
-): string {
-  return md5FromString(JSON.stringify(objectSortedEntriesDeep(obj)), encoding);
-}
-
-export function md5FromFilePath(
-  fs: FileSystem,
-  filePath: string,
-): Promise<string> {
-  return md5FromReadableStream(fs.createReadStream(filePath));
-}

package/src/promisify.js

@@ -1,13 +0,0 @@
-module.exports = function(fn) {
-  return function(...args) {
-    return new Promise(function(resolve, reject) {
-      fn(...args, function(err, ...res) {
-        if (err) return reject(err);
-
-        if (res.length === 1) return resolve(res[0]);
-
-        resolve(res);
-      });
-    });
-  };
-};