@atlaspack/utils 2.14.5-canary.14 → 2.14.5-canary.141

package/lib/replaceBundleReferences.js

@@ -0,0 +1,199 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getURLReplacement = getURLReplacement;
+exports.replaceInlineReferences = replaceInlineReferences;
+exports.replaceURLReferences = replaceURLReferences;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+var _ = require("./");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Replaces references to dependency ids for URL dependencies with:
+ *   - in the case of an unresolvable url dependency, the original specifier.
+ *     These are external requests that Parcel did not bundle.
+ *   - in the case of a reference to another bundle, the relative url to that
+ *     bundle from the current bundle.
+ */
+function replaceURLReferences({
+  bundle,
+  bundleGraph,
+  contents,
+  map,
+  getReplacement = s => s,
+  relative = true
+}) {
+  let replacements = new Map();
+  let urlDependencies = [];
+  bundle.traverse(node => {
+    if (node.type === 'dependency' && node.value.specifierType === 'url') {
+      urlDependencies.push(node.value);
+    }
+  });
+  for (let dependency of urlDependencies) {
+    var _dependency$meta;
+    if (dependency.specifierType !== 'url') {
+      continue;
+    }
+    let placeholder = ((_dependency$meta = dependency.meta) === null || _dependency$meta === void 0 ? void 0 : _dependency$meta.placeholder) ?? dependency.id;
+    (0, _assert().default)(typeof placeholder === 'string');
+    let resolved = bundleGraph.getReferencedBundle(dependency, bundle);
+    if (resolved == null) {
+      replacements.set(placeholder, {
+        from: placeholder,
+        to: getReplacement(dependency.specifier)
+      });
+      continue;
+    }
+    if (resolved.bundleBehavior === 'inline') {
+      // If a bundle is inline, it should be replaced with inline contents,
+      // not a URL.
+      continue;
+    }
+    replacements.set(placeholder, getURLReplacement({
+      dependency,
+      fromBundle: bundle,
+      toBundle: resolved,
+      relative,
+      getReplacement
+    }));
+  }
+  return performReplacement(replacements, contents, map);
+}
+
+/*
+ * Replaces references to dependency ids for inline bundles with the packaged
+ * contents of that bundle.
+ */
+async function replaceInlineReferences({
+  bundle,
+  bundleGraph,
+  contents,
+  map,
+  getInlineReplacement,
+  getInlineBundleContents
+}) {
+  let replacements = new Map();
+  let dependencies = [];
+  bundle.traverse(node => {
+    if (node.type === 'dependency') {
+      dependencies.push(node.value);
+    }
+  });
+  for (let dependency of dependencies) {
+    let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
+    if ((entryBundle === null || entryBundle === void 0 ? void 0 : entryBundle.bundleBehavior) !== 'inline') {
+      continue;
+    }
+    let packagedBundle = await getInlineBundleContents(entryBundle, bundleGraph);
+    let packagedContents = (packagedBundle.contents instanceof _stream().Readable ? await (0, _.bufferStream)(packagedBundle.contents) : packagedBundle.contents).toString();
+    let inlineType = (0, _nullthrows().default)(entryBundle.getMainEntry()).meta.inlineType;
+    if (inlineType == null || inlineType === 'string') {
+      var _dependency$meta2;
+      let placeholder = ((_dependency$meta2 = dependency.meta) === null || _dependency$meta2 === void 0 ? void 0 : _dependency$meta2.placeholder) ?? dependency.id;
+      (0, _assert().default)(typeof placeholder === 'string');
+      replacements.set(placeholder, getInlineReplacement(dependency, inlineType, packagedContents));
+    }
+  }
+  return performReplacement(replacements, contents, map);
+}
+function getURLReplacement({
+  dependency,
+  fromBundle,
+  toBundle,
+  relative,
+  getReplacement
+}) {
+  var _dependency$meta3;
+  let to;
+  let orig = _url().default.parse(dependency.specifier);
+  if (relative) {
+    to = _url().default.format({
+      pathname: (0, _.relativeBundlePath)(fromBundle, toBundle, {
+        leadingDotSlash: false
+      }),
+      hash: orig.hash
+    });
+
+    // If the resulting path includes a colon character and doesn't start with a ./ or ../
+    // we need to add one so that the first part before the colon isn't parsed as a URL protocol.
+    if (to.includes(':') && !to.startsWith('./') && !to.startsWith('../')) {
+      to = './' + to;
+    }
+  } else {
+    to = (0, _.urlJoin)(toBundle.target.publicUrl, _url().default.format({
+      pathname: (0, _nullthrows().default)(toBundle.name),
+      hash: orig.hash
+    }));
+  }
+  let placeholder = ((_dependency$meta3 = dependency.meta) === null || _dependency$meta3 === void 0 ? void 0 : _dependency$meta3.placeholder) ?? dependency.id;
+  (0, _assert().default)(typeof placeholder === 'string');
+  return {
+    from: placeholder,
+    to: getReplacement ? getReplacement(to) : to
+  };
+}
+function performReplacement(replacements, contents, map) {
+  let finalContents = contents;
+  if ((0, _featureFlags().getFeatureFlag)('inlineStringReplacementPerf')) {
+    let replacementList = Array.from(replacements.values());
+    if (replacementList.length > 0) {
+      finalContents = (0, _rust().performStringReplacements)(contents, replacementList);
+    }
+  } else {
+    for (let {
+      from,
+      to
+    } of replacements.values()) {
+      // Perform replacement
+      finalContents = finalContents.split(from).join(to);
+    }
+  }
+  return {
+    contents: finalContents,
+    // TODO: Update sourcemap with adjusted contents
+    map
+  };
+}

package/lib/schema.d.ts

@@ -0,0 +1,107 @@
+import type { Mapping } from '@mischnic/json-sourcemap';
+export type SchemaEntity = SchemaObject | SchemaArray | SchemaBoolean | SchemaString | SchemaNumber | SchemaEnum | SchemaOneOf | SchemaAllOf | SchemaNot | SchemaAny;
+export type SchemaArray = {
+    type: 'array';
+    items?: SchemaEntity;
+    __type?: string;
+};
+export type SchemaBoolean = {
+    type: 'boolean';
+    __type?: string;
+};
+export type SchemaOneOf = {
+    oneOf: Array<SchemaEntity>;
+};
+export type SchemaAllOf = {
+    allOf: Array<SchemaEntity>;
+};
+export type SchemaNot = {
+    not: SchemaEntity;
+    __message: string;
+};
+export type SchemaString = {
+    type: 'string';
+    enum?: Array<string>;
+    __validate?: (val: string) => string | null | undefined;
+    __type?: string;
+};
+export type SchemaNumber = {
+    type: 'number';
+    enum?: Array<number>;
+    __type?: string;
+};
+export type SchemaEnum = {
+    enum: Array<unknown>;
+};
+export type SchemaObject = {
+    type: 'object';
+    properties: {
+        [key: string]: SchemaEntity;
+    };
+    additionalProperties?: boolean | SchemaEntity;
+    required?: Array<string>;
+    __forbiddenProperties?: Array<string>;
+    __type?: string;
+};
+export type SchemaAny = Record<any, any>;
+export type SchemaError = {
+    type: 'type';
+    expectedTypes: Array<string>;
+    dataType: 'key' | null | undefined | 'value';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'enum';
+    expectedValues: Array<unknown>;
+    dataType: 'key' | 'value';
+    actualValue: unknown;
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'forbidden-prop';
+    prop: string;
+    expectedProps: Array<string>;
+    actualProps: Array<string>;
+    dataType: 'key';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'missing-prop';
+    prop: string;
+    expectedProps: Array<string>;
+    actualProps: Array<string>;
+    dataType: 'key' | 'value';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'other';
+    actualValue: unknown;
+    dataType: 'key' | null | undefined | 'value';
+    message?: string;
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+};
+declare function validateSchema(schema: SchemaEntity, data: unknown): Array<SchemaError>;
+declare namespace validateSchema {
+    var diagnostic: (schema: SchemaEntity, data: ({
+        source?: string | null | undefined;
+        data?: unknown;
+    } | {
+        source: string;
+        map: {
+            data: unknown;
+            pointers: {
+                [key: string]: Mapping;
+            };
+        };
+    }) & {
+        filePath?: string | null | undefined;
+        prependKey?: string | null | undefined;
+    }, origin: string, message: string) => undefined;
+}
+export default validateSchema;
+export declare function fuzzySearch(expectedValues: Array<string>, actualValue: string): Array<string>;

package/lib/schema.js

@@ -0,0 +1,355 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.fuzzySearch = fuzzySearch;
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function levenshtein() {
+  const data = _interopRequireWildcard(require("fastest-levenshtein"));
+  levenshtein = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function validateSchema(schema, data) {
+  function walk(
+  // @ts-expect-error TS7006
+  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 = [];
+                // @ts-expect-error TS18046
+                for (let i = 0; i < dataNode.length; i++) {
+                  let result = walk([schemaNode.items].concat(schemaAncestors),
+                  // @ts-expect-error TS18046
+                  dataNode[i], dataPath + '/' + i);
+                  if (result) results.push(result);
+                }
+                if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
+              }
+              break;
+            }
+          case 'string':
+            {
+              // @ts-expect-error TS2322
+              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);
+                if (typeof validationError == 'string') {
+                  return {
+                    type: 'other',
+                    dataType: 'value',
+                    dataPath,
+                    message: validationError,
+                    actualValue: value,
+                    ancestors: schemaAncestors
+                  };
+                }
+              }
+              break;
+            }
+          case 'number':
+            {
+              // @ts-expect-error TS2322
+              let value = dataNode;
+              if (schemaNode.enum) {
+                if (!schemaNode.enum.includes(value)) {
+                  return {
+                    type: 'enum',
+                    dataType: 'value',
+                    dataPath,
+                    expectedValues: schemaNode.enum,
+                    actualValue: value,
+                    ancestors: schemaAncestors
+                  };
+                }
+              }
+              break;
+            }
+          case 'object':
+            {
+              let results = [];
+              let invalidProps;
+              if (schemaNode.__forbiddenProperties) {
+                // @ts-expect-error TS2769
+                let keys = Object.keys(dataNode);
+                // @ts-expect-error TS7006
+                invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
+                results.push(...invalidProps.map(
+                // @ts-expect-error TS7006
+                k => ({
+                  type: 'forbidden-prop',
+                  dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                  dataType: 'key',
+                  prop: k,
+                  expectedProps: Object.keys(schemaNode.properties),
+                  actualProps: keys,
+                  ancestors: schemaAncestors
+                })));
+              }
+              if (schemaNode.required) {
+                // @ts-expect-error TS2769
+                let keys = Object.keys(dataNode);
+                let missingKeys = schemaNode.required.filter(
+                // @ts-expect-error TS7006
+                val => !keys.includes(val));
+                results.push(...missingKeys.map(
+                // @ts-expect-error TS7006
+                k => ({
+                  type: 'missing-prop',
+                  dataPath,
+                  dataType: 'value',
+                  prop: k,
+                  expectedProps: schemaNode.required,
+                  actualProps: keys,
+                  ancestors: schemaAncestors
+                })));
+              }
+              if (schemaNode.properties) {
+                let {
+                  additionalProperties = true
+                } = schemaNode;
+                // @ts-expect-error TS2407
+                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),
+                    // @ts-expect-error TS18046
+                    dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
+                    if (result) results.push(result);
+                  } else {
+                    if (typeof additionalProperties === 'boolean') {
+                      if (!additionalProperties) {
+                        results.push({
+                          type: 'enum',
+                          dataType: 'key',
+                          dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                          expectedValues: Object.keys(schemaNode.properties
+                          // @ts-expect-error TS18046
+                          ).filter(p => !(p in dataNode)),
+                          actualValue: k,
+                          ancestors: schemaAncestors,
+                          prettyType: schemaNode.__type
+                        });
+                      }
+                    } else {
+                      let result = walk([additionalProperties].concat(schemaAncestors),
+                      // @ts-expect-error TS18046
+                      dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(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);
+        // @ts-expect-error TS2339
+        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 = exports.default = validateSchema;
+function fuzzySearch(expectedValues, actualValue) {
+  let result = expectedValues.map(exp => [exp, levenshtein().distance(exp, actualValue)]).filter(
+  // Remove if more than half of the string would need to be changed
+  // @ts-expect-error TS2769
+  ([, d]) => d * 2 < actualValue.length);
+  // @ts-expect-error TS2345
+  result.sort(([, a], [, b]) => a - b);
+  // @ts-expect-error TS2345
+  return result.map(([v]) => v);
+}
+validateSchema.diagnostic = function (schema, data, origin, message) {
+  if ('source' in data && 'data' in data && typeof data.source !== 'string' && !data) {
+    throw new Error('At least one of data.source and data.data must be defined!');
+  }
+  // @ts-expect-error TS2339
+  let object = data.map ?
+  // @ts-expect-error TS2339
+  data.map.data :
+  // @ts-expect-error TS2339
+  data.data ?? JSON.parse(data.source);
+  let errors = validateSchema(schema, object);
+  if (errors.length) {
+    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 ${JSON.stringify(prop)}?`;
+          e.dataPath += '/' + likely[0];
+          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 map, code;
+    // @ts-expect-error TS2339
+    if (data.map) {
+      // @ts-expect-error TS2339
+      map = data.map;
+      code = data.source;
+    } else {
+      // @ts-expect-error TS2339
+      map = data.source ?? JSON.stringify((0, _nullthrows().default)(data.data), 0, '\t');
+      code = map;
+    }
+    let codeFrames = [{
+      filePath: data.filePath ?? undefined,
+      language: 'json',
+      code,
+      codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(map, keys.map(({
+        key,
+        type,
+        message
+      }) => ({
+        key: (data.prependKey ?? '') + key,
+        type: type,
+        message: message != null ? (0, _diagnostic().escapeMarkdown)(message) : message
+      })))
+    }];
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: message,
+        origin,
+        // @ts-expect-error TS2322
+        codeFrames
+      }
+    });
+  }
+};

package/lib/shared-buffer.d.ts

@@ -0,0 +1,2 @@
+export type Class<T> = new (...args: any[]) => T;
+export declare let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;

package/lib/shared-buffer.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedBuffer = void 0;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
+let SharedBuffer = exports.SharedBuffer = void 0;
+
+// @ts-expect-error process.browser is a browser-specific property
+if (process.browser) {
+  exports.SharedBuffer = SharedBuffer = ArrayBuffer;
+  // Safari has removed the constructor
+  if (typeof SharedArrayBuffer !== 'undefined') {
+    let channel = new MessageChannel();
+    try {
+      // Firefox might throw when sending the Buffer over a MessagePort
+      channel.port1.postMessage(new SharedArrayBuffer(0));
+      exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+    } catch (_) {
+      // NOOP
+    }
+    channel.port1.close();
+    channel.port2.close();
+  }
+} else {
+  exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+}