@atlaspack/utils 2.17.3-typescript-e99c742e9.0 → 2.17.3-typescript-5b4d3ad41.0

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;
+}

package/lib/sourcemap.d.ts

@@ -0,0 +1,16 @@
+import type { SourceLocation } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import SourceMap from '@parcel/source-map';
+export declare const SOURCEMAP_RE: RegExp;
+export declare const SOURCEMAP_EXTENSIONS: Set<string>;
+export declare function matchSourceMappingURL(contents: string): RegExpMatchArray | null;
+export declare function loadSourceMapUrl(fs: FileSystem, filename: string, contents: string): Promise<{
+    filename: string;
+    map: any;
+    url: string;
+} | null | undefined>;
+export declare function loadSourceMap(filename: string, contents: string, options: {
+    fs: FileSystem;
+    projectRoot: string;
+}): Promise<SourceMap | null | undefined>;
+export declare function remapSourceLocation(loc: SourceLocation, originalMap: SourceMap): SourceLocation;

package/lib/sourcemap.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SOURCEMAP_RE = exports.SOURCEMAP_EXTENSIONS = void 0;
+exports.loadSourceMap = loadSourceMap;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.remapSourceLocation = remapSourceLocation;
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _path2 = require("./path");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SOURCEMAP_RE = exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+const SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_EXTENSIONS = new Set(['css', 'es', 'es6', 'js', 'jsx', 'mjs', 'ts', 'tsx']);
+function matchSourceMappingURL(contents) {
+  return contents.match(SOURCEMAP_RE);
+}
+async function loadSourceMapUrl(fs, filename, contents) {
+  let match = matchSourceMappingURL(contents);
+  if (match) {
+    let url = match[1].trim();
+    let dataURLMatch = url.match(DATA_URL_RE);
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = (0, _path2.isAbsolute)(mapFilePath) ? mapFilePath : _path().default.join(_path().default.dirname(filename), mapFilePath);
+    }
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(dataURLMatch ? Buffer.from(dataURLMatch[1], 'base64').toString() : await fs.readFile(mapFilePath, 'utf8'))
+    };
+  }
+}
+async function loadSourceMap(filename, contents, options) {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+  if (foundMap) {
+    let mapSourceRoot = _path().default.dirname(filename);
+    if (foundMap.map.sourceRoot && !(0, _path2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+      mapSourceRoot = _path().default.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+    let sourcemapInstance = new (_sourceMap().default)(options.projectRoot);
+    sourcemapInstance.addVLQMap({
+      ...foundMap.map,
+      sources: foundMap.map.sources.map(s => {
+        return _path().default.join(mapSourceRoot, s);
+      })
+    });
+    return sourcemapInstance;
+  }
+}
+function remapSourceLocation(loc, originalMap) {
+  let {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  } = loc;
+  let lineDiff = endLine - startLine;
+  let colDiff = endCol - startCol;
+  let start = originalMap.findClosestMapping(startLine, startCol - 1);
+  let end = originalMap.findClosestMapping(endLine, endCol - 1);
+  if (start !== null && start !== void 0 && start.original) {
+    if (start.source) {
+      filePath = start.source;
+    }
+    ({
+      line: startLine,
+      column: startCol
+    } = start.original);
+    startCol++; // source map columns are 0-based
+  }
+
+  if (end !== null && end !== void 0 && end.original) {
+    ({
+      line: endLine,
+      column: endCol
+    } = end.original);
+    endCol++; // source map columns are 0-based
+
+    if (endLine < startLine) {
+      endLine = startLine;
+      endCol = startCol;
+    } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+      endCol = startCol + colDiff;
+    } else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+      // Prevent 0-length ranges
+      endCol = startCol + 1;
+    }
+  } else {
+    endLine = startLine;
+    endCol = startCol;
+  }
+  return {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  };
+}

package/lib/stream.d.ts

@@ -0,0 +1,8 @@
+import { Readable } from 'stream';
+import type { Blob } from '@atlaspack/types';
+export declare function measureStreamLength(stream: Readable): Promise<number>;
+export declare function readableFromStringOrBuffer(str: string | Buffer): Readable;
+export declare function bufferStream(stream: Readable): Promise<Buffer>;
+export declare function blobToStream(blob: Blob): Readable;
+export declare function streamFromPromise(promise: Promise<Blob>): Readable;
+export declare function fallbackStream(stream: Readable, fallback: () => Readable): Readable;